Remove isolate parameter when allocating 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 "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/class_finalizer.h"
@@ skipping 67 matching lines @@
   }
 }
 
 
 #if defined(DEBUG)
 // An object visitor which will iterate over all the function objects in the
 // heap and check if the result type and parameter types are canonicalized
 // or not. An assertion is raised if a type is not canonicalized.
 class FunctionVisitor : public ObjectVisitor {
  public:
-  explicit FunctionVisitor(Isolate* isolate) :
-      ObjectVisitor(isolate),
-      classHandle_(Class::Handle(isolate)),
-      funcHandle_(Function::Handle(isolate)),
-      typeHandle_(AbstractType::Handle(isolate)) {}
+  explicit FunctionVisitor(Thread* thread) :
+      ObjectVisitor(thread->isolate()),
+      classHandle_(Class::Handle(thread->zone())),
+      funcHandle_(Function::Handle(thread->zone())),
+      typeHandle_(AbstractType::Handle(thread->zone())) {}
 
   void VisitObject(RawObject* obj) {
     if (obj->IsFunction()) {
       funcHandle_ ^= obj;
       classHandle_ ^= funcHandle_.Owner();
       // Verify that the result type of a function is canonical or a
       // TypeParameter.
       typeHandle_ ^= funcHandle_.result_type();
       ASSERT(typeHandle_.IsNull() ||
              !typeHandle_.IsResolved() ||
@@ skipping 287 matching lines @@
          Dart::IsReadOnlyApiHandle(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,                          \
+  const type& Api::Unwrap##type##Handle(Zone* zone,                            \
                                         Dart_Handle dart_handle) {             \
-    const Object& obj = Object::Handle(iso, Api::UnwrapHandle(dart_handle));   \
+    const Object& obj = Object::Handle(zone, Api::UnwrapHandle(dart_handle));  \
     if (obj.Is##type()) {                                                      \
       return type::Cast(obj);                                                  \
     }                                                                          \
-    return type::Handle(iso);                                                  \
+    return type::Handle(zone  );                                               \
   }
 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()) {
@@ skipping 406 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_NewUnhandledExceptionError(Dart_Handle exception) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
 
   Instance& obj = Instance::Handle(Z);
   intptr_t class_id = Api::ClassId(exception);
   if ((class_id == kApiErrorCid) || (class_id == kLanguageErrorCid)) {
     obj = String::New(::Dart_GetError(exception));
   } else {
-    obj = Api::UnwrapInstanceHandle(I, exception).raw();
+    obj = Api::UnwrapInstanceHandle(Z, exception).raw();
     if (obj.IsNull()) {
-      RETURN_TYPE_ERROR(I, exception, Instance);
+      RETURN_TYPE_ERROR(Z, exception, Instance);
     }
   }
   const Stacktrace& stacktrace = Stacktrace::Handle(Z);
   return Api::NewHandle(I, UnhandledException::New(obj, stacktrace));
 }
 
 
 DART_EXPORT Dart_Handle Dart_PropagateError(Dart_Handle handle) {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
   {
-    const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(handle));
+    const Object& obj = Object::Handle(thread->zone(),
+        Api::UnwrapHandle(handle));
     if (!obj.IsError()) {
       return Api::NewError(
           "%s expects argument 'handle' to be an error handle.  "
           "Did you forget to check Dart_IsError first?",
           CURRENT_FUNC);
     }
   }
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // propagate an error here.
     return Api::NewError("No Dart frames on stack, cannot propagate error.");
   }
 
   // Unwind all the API scopes till the exit frame before propagating.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Error* error;
   {
     // We need to preserve the error object across the destruction of zones
     // when the ApiScopes are unwound.  By using NoSafepointScope, we can ensure
     // that GC won't touch the raw error object before creating a valid
     // handle for it in the surviving zone.
     NoSafepointScope no_safepoint;
-    RawError* raw_error = Api::UnwrapErrorHandle(isolate, handle).raw();
+    RawError* raw_error = Api::UnwrapErrorHandle(thread->zone(), handle).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
-    error = &Error::Handle(isolate, raw_error);
+    // Note that thread's zone is different here than at the beginning of this
+    // function.
+    error = &Error::Handle(thread->zone(), raw_error);
   }
   Exceptions::PropagateError(*error);
   UNREACHABLE();
   return Api::NewError("Cannot reach here.  Internal error.");
 }
 
 
 DART_EXPORT void _Dart_ReportErrorHandle(const char* file,
                                          int line,
                                          const char* handle,
@@ skipping 640 matching lines @@
   if (isolate_snapshot_size == NULL) {
     RETURN_NULL_ERROR(isolate_snapshot_size);
   }
   // Finalize all classes if needed.
   Dart_Handle state = Api::CheckAndFinalizePendingClasses(I);
   if (::Dart_IsError(state)) {
     return state;
   }
   I->heap()->CollectAllGarbage();
 #if defined(DEBUG)
-  FunctionVisitor check_canonical(I);
+  FunctionVisitor check_canonical(T);
   I->heap()->IterateObjects(&check_canonical);
 #endif  // #if defined(DEBUG).
 
   // Since this is only a snapshot the root library should not be set.
   I->object_store()->set_root_library(Library::Handle(Z));
   FullSnapshotWriter writer(vm_isolate_snapshot_buffer,
                             isolate_snapshot_buffer,
                             NULL, /* instructions_snapshot_buffer */
                             ApiReallocate,
                             false, /* snapshot_code */
@@ skipping 21 matching lines @@
     return state;
   }
   Library& lib = Library::Handle(Z);
   if (library == Dart_Null()) {
     lib ^= I->object_store()->root_library();
   } else {
     lib ^= Api::UnwrapHandle(library);
   }
   I->heap()->CollectAllGarbage();
 #if defined(DEBUG)
-  FunctionVisitor check_canonical(I);
+  FunctionVisitor check_canonical(T);
   I->heap()->IterateObjects(&check_canonical);
 #endif  // #if defined(DEBUG).
   ScriptSnapshotWriter writer(buffer, ApiReallocate);
   writer.WriteScriptSnapshot(lib);
   *size = writer.BytesWritten();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateScriptSnapshot(uint8_t** buffer,
@@ skipping 164 matching lines @@
                          port_id);
   }
   return Api::NewHandle(I, SendPort::New(port_id));
 }
 
 
 DART_EXPORT Dart_Handle Dart_SendPortGetId(Dart_Handle port,
                                            Dart_Port* port_id) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
-  const SendPort& send_port = Api::UnwrapSendPortHandle(I, port);
+  const SendPort& send_port = Api::UnwrapSendPortHandle(Z, port);
   if (send_port.IsNull()) {
-    RETURN_TYPE_ERROR(I, port, SendPort);
+    RETURN_TYPE_ERROR(Z, port, SendPort);
   }
   if (port_id == NULL) {
     RETURN_NULL_ERROR(port_id);
   }
   *port_id = send_port.Id();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Port Dart_GetMainPortId() {
@@ skipping 102 matching lines @@
 
 
 // TODO(iposva): This call actually implements IsInstanceOfClass.
 // Do we also need a real Dart_IsInstanceOf, which should take an instance
 // rather than an object?
 DART_EXPORT Dart_Handle Dart_ObjectIsType(Dart_Handle object,
                                           Dart_Handle type,
                                           bool* value) {
   DARTSCOPE(Thread::Current());
 
-  const Type& type_obj = Api::UnwrapTypeHandle(I, type);
+  const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
   if (type_obj.IsNull()) {
     *value = false;
-    RETURN_TYPE_ERROR(I, type, Type);
+    RETURN_TYPE_ERROR(Z, type, Type);
   }
   if (!type_obj.IsFinalized()) {
     return Api::NewError(
         "%s expects argument 'type' to be a fully resolved type.",
         CURRENT_FUNC);
   }
   if (object == Api::Null()) {
     *value = false;
     return Api::Success();
   }
-  const Instance& instance = Api::UnwrapInstanceHandle(I, object);
+  const Instance& instance = Api::UnwrapInstanceHandle(Z, object);
   if (instance.IsNull()) {
     *value = false;
-    RETURN_TYPE_ERROR(I, object, Instance);
+    RETURN_TYPE_ERROR(Z, object, Instance);
   }
   CHECK_CALLBACK_STATE(I);
   Error& malformed_type_error = Error::Handle(Z);
   *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();
 }
 
@@ skipping 149 matching lines @@
 
 // --- Instances ----
 
 DART_EXPORT Dart_Handle Dart_InstanceGetType(Dart_Handle instance) {
   DARTSCOPE(Thread::Current());
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(instance));
   if (obj.IsNull()) {
     return Api::NewHandle(I, I->object_store()->null_type());
   }
   if (!obj.IsInstance()) {
-    RETURN_TYPE_ERROR(I, instance, Instance);
+    RETURN_TYPE_ERROR(Z, instance, Instance);
   }
   const Type& type = Type::Handle(Instance::Cast(obj).GetType());
   return Api::NewHandle(I, type.Canonicalize());
 }
 
 
 // --- Numbers, Integers and Doubles ----
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
   // Fast path for Smis and Mints.
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   intptr_t class_id = Api::ClassId(integer);
   if (class_id == kSmiCid || class_id == kMintCid) {
     *fits = true;
     return Api::Success();
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
-  const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
+  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, integer, Integer);
+    RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   ASSERT(!Bigint::Cast(int_obj).FitsIntoInt64());
   *fits = false;
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer,
                                                    bool* fits) {
   // Fast path for Smis.
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *fits = (Api::SmiValue(integer) >= 0);
     return Api::Success();
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
-  const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
+  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, integer, Integer);
+    RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
     *fits = Bigint::Cast(int_obj).FitsIntoUint64();
   }
   return Api::Success();
 }
 
@@ skipping 34 matching lines @@
   // Fast path for Smis.
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *value = Api::SmiValue(integer);
     return Api::Success();
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
-  const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
+  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, integer, Integer);
+    RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success();
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (bigint.FitsIntoInt64()) {
       *value = bigint.AsInt64Value();
       return Api::Success();
@@ skipping 12 matching lines @@
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     intptr_t smi_value = Api::SmiValue(integer);
     if (smi_value >= 0) {
       *value = smi_value;
       return Api::Success();
     }
   }
   // Slow path for Mints and Bigints.
   DARTSCOPE(thread);
-  const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
+  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, integer, Integer);
+    RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   if (int_obj.IsSmi()) {
     ASSERT(int_obj.IsNegative());
   } else if (int_obj.IsMint() && !int_obj.IsNegative()) {
     *value = int_obj.AsInt64Value();
     return Api::Success();
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
     if (bigint.FitsIntoUint64()) {
       *value = bigint.AsUint64Value();
       return Api::Success();
     }
   }
   return Api::NewError("%s: Integer %s cannot be represented as a uint64_t.",
                        CURRENT_FUNC, int_obj.ToCString());
 }
 
 
 static uword BigintAllocate(intptr_t size) {
   return Api::TopScope(Isolate::Current())->zone()->AllocUnsafe(size);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToHexCString(Dart_Handle integer,
                                                  const char** value) {
   DARTSCOPE(Thread::Current());
-  const Integer& int_obj = Api::UnwrapIntegerHandle(I, integer);
+  const Integer& int_obj = Api::UnwrapIntegerHandle(Z, integer);
   if (int_obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, integer, Integer);
+    RETURN_TYPE_ERROR(Z, integer, Integer);
   }
   if (int_obj.IsSmi() || int_obj.IsMint()) {
     const Bigint& bigint = Bigint::Handle(Z,
         Bigint::NewFromInt64(int_obj.AsInt64Value()));
     *value = bigint.ToHexCString(BigintAllocate);
   } else {
     *value = Bigint::Cast(int_obj).ToHexCString(BigintAllocate);
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
   return Api::NewHandle(I, Double::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj,
                                          double* value) {
   DARTSCOPE(Thread::Current());
-  const Double& obj = Api::UnwrapDoubleHandle(I, double_obj);
+  const Double& obj = Api::UnwrapDoubleHandle(Z, double_obj);
   if (obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, double_obj, Double);
+    RETURN_TYPE_ERROR(Z, double_obj, Double);
   }
   *value = obj.value();
   return Api::Success();
 }
 
 
 // --- Booleans ----
 
 DART_EXPORT Dart_Handle Dart_True() {
   ASSERT(Isolate::Current() != NULL);
@@ skipping 10 matching lines @@
 DART_EXPORT Dart_Handle Dart_NewBoolean(bool value) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   return value ? Api::True() : Api::False();
 }
 
 
 DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle boolean_obj,
                                           bool* value) {
   DARTSCOPE(Thread::Current());
-  const Bool& obj = Api::UnwrapBoolHandle(I, boolean_obj);
+  const Bool& obj = Api::UnwrapBoolHandle(Z, boolean_obj);
   if (obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, boolean_obj, Bool);
+    RETURN_TYPE_ERROR(Z, boolean_obj, Bool);
   }
   *value = obj.value();
   return Api::Success();
 }
 
 
 // --- Strings ---
 
 
 DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t* len) {
   Thread* thread = Thread::Current();
   CHECK_ISOLATE(thread->isolate());
   ReusableObjectHandleScope reused_obj_handle(thread);
   const String& str_obj = Api::UnwrapStringHandle(reused_obj_handle, str);
   if (str_obj.IsNull()) {
-    RETURN_TYPE_ERROR(thread->isolate(), str, String);
+    RETURN_TYPE_ERROR(thread->zone(), str, String);
   }
   *len = str_obj.Length();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewStringFromCString(const char* str) {
   DARTSCOPE(Thread::Current());
   if (str == NULL) {
     RETURN_NULL_ERROR(str);
@@ skipping 82 matching lines @@
                                             SpaceForExternal(I, bytes)));
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle object,
                                              const char** cstr) {
   DARTSCOPE(Thread::Current());
   if (cstr == NULL) {
     RETURN_NULL_ERROR(cstr);
   }
-  const String& str_obj = Api::UnwrapStringHandle(I, object);
+  const String& str_obj = Api::UnwrapStringHandle(Z, object);
   if (str_obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, object, String);
+    RETURN_TYPE_ERROR(Z, object, String);
   }
   intptr_t string_length = Utf8::Length(str_obj);
   char* res = Api::TopScope(I)->zone()->Alloc<char>(string_length + 1);
   if (res == NULL) {
     return Api::NewError("Unable to allocate memory");
   }
   const char* string_value = str_obj.ToCString();
   memmove(res, string_value, string_length + 1);
   ASSERT(res[string_length] == '\0');
   *cstr = res;
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToUTF8(Dart_Handle str,
                                           uint8_t** utf8_array,
                                           intptr_t* length) {
   DARTSCOPE(Thread::Current());
   if (utf8_array == NULL) {
     RETURN_NULL_ERROR(utf8_array);
   }
   if (length == NULL) {
     RETURN_NULL_ERROR(length);
   }
-  const String& str_obj = Api::UnwrapStringHandle(I, str);
+  const String& str_obj = Api::UnwrapStringHandle(Z, str);
   if (str_obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, str, String);
+    RETURN_TYPE_ERROR(Z, str, String);
   }
   intptr_t str_len = Utf8::Length(str_obj);
   *utf8_array = Api::TopScope(I)->zone()->Alloc<uint8_t>(str_len);
   if (*utf8_array == NULL) {
     return Api::NewError("Unable to allocate memory");
   }
   str_obj.ToUTF8(*utf8_array, str_len);
   *length = str_len;
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToLatin1(Dart_Handle str,
                                             uint8_t* latin1_array,
                                             intptr_t* length) {
   DARTSCOPE(Thread::Current());
   if (latin1_array == NULL) {
     RETURN_NULL_ERROR(latin1_array);
   }
   if (length == NULL) {
     RETURN_NULL_ERROR(length);
   }
-  const String& str_obj = Api::UnwrapStringHandle(I, str);
+  const String& str_obj = Api::UnwrapStringHandle(Z, str);
   if (str_obj.IsNull() || !str_obj.IsOneByteString()) {
-    RETURN_TYPE_ERROR(I, str, String);
+    RETURN_TYPE_ERROR(Z, str, String);
   }
   intptr_t str_len = str_obj.Length();
   intptr_t copy_len = (str_len > *length) ? *length : str_len;
 
   // We have already asserted that the string object is a Latin-1 string
   // so we can copy the characters over using a simple loop.
   for (intptr_t i = 0; i < copy_len; i++) {
     latin1_array[i] = str_obj.CharAt(i);
   }
   *length = copy_len;
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToUTF16(Dart_Handle str,
                                            uint16_t* utf16_array,
                                            intptr_t* length) {
   DARTSCOPE(Thread::Current());
-  const String& str_obj = Api::UnwrapStringHandle(I, str);
+  const String& str_obj = Api::UnwrapStringHandle(Z, str);
   if (str_obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, str, String);
+    RETURN_TYPE_ERROR(Z, str, String);
   }
   intptr_t str_len = str_obj.Length();
   intptr_t copy_len = (str_len > *length) ? *length : str_len;
   for (intptr_t i = 0; i < copy_len; i++) {
     utf16_array[i] = str_obj.CharAt(i);
   }
   *length = copy_len;
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringStorageSize(Dart_Handle str,
                                                intptr_t* size) {
   Thread* thread = Thread::Current();
   CHECK_ISOLATE(thread->isolate());
   ReusableObjectHandleScope reused_obj_handle(thread);
   const String& str_obj = Api::UnwrapStringHandle(reused_obj_handle, str);
   if (str_obj.IsNull()) {
-    RETURN_TYPE_ERROR(thread->isolate(), str, String);
+    RETURN_TYPE_ERROR(thread->zone(), str, String);
   }
   if (size == NULL) {
     RETURN_NULL_ERROR(size);
   }
   *size = (str_obj.Length() * str_obj.CharSize());
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_MakeExternalString(Dart_Handle str,
                                                 void* array,
                                                 intptr_t length,
                                                 void* peer,
                                                 Dart_PeerFinalizer cback) {
   DARTSCOPE(Thread::Current());
-  const String& str_obj = Api::UnwrapStringHandle(I, str);
+  const String& str_obj = Api::UnwrapStringHandle(Z, str);
   if (str_obj.IsExternal()) {
     return str;  // String is already an external string.
   }
   if (str_obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, str, String);
+    RETURN_TYPE_ERROR(Z, str, String);
   }
   if (array == NULL) {
     RETURN_NULL_ERROR(array);
   }
   intptr_t str_size = (str_obj.Length() * str_obj.CharSize());
   if ((length < str_size) || (length > String::kMaxElements)) {
     return Api::NewError("Dart_MakeExternalString "
                          "expects argument length to be in the range"
                          "[%" Pd "..%" Pd "].",
                          str_size, String::kMaxElements);
@@ skipping 29 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_StringGetProperties(Dart_Handle object,
                                                  intptr_t* char_size,
                                                  intptr_t* str_len,
                                                  void** peer) {
   Thread* thread = Thread::Current();
   CHECK_ISOLATE(thread->isolate());
   ReusableObjectHandleScope reused_obj_handle(thread);
   const String& str = Api::UnwrapStringHandle(reused_obj_handle, object);
   if (str.IsNull()) {
-    RETURN_TYPE_ERROR(thread->isolate(), object, String);
+    RETURN_TYPE_ERROR(thread->zone(), object, String);
   }
   if (str.IsExternal()) {
     *peer = str.GetPeer();
     ASSERT(*peer != NULL);
   } else {
     NoSafepointScope no_safepoint_scope;
     *peer = thread->isolate()->heap()->GetPeer(str.raw());
   }
   *char_size = str.CharSize();
   *str_len = str.Length();
@@ skipping 176 matching lines @@
     }
     return Api::NewError("Object does not implement the 'List' interface");
   }
 }
 
 
 #define SET_LIST_ELEMENT(type, obj, index, value)                              \
   const type& array = type::Cast(obj);                                         \
   const Object& value_obj = Object::Handle(Z, Api::UnwrapHandle(value));       \
   if (!value_obj.IsNull() && !value_obj.IsInstance()) {                        \
-    RETURN_TYPE_ERROR(I, value, Instance);                                     \
+    RETURN_TYPE_ERROR(Z, value, Instance);                                     \
   }                                                                            \
   if ((index >= 0) && (index < array.Length())) {                              \
     array.SetAt(index, value_obj);                                             \
     return Api::Success();                                                     \
   }                                                                            \
   return Api::NewError("Invalid index passed in to set list element");         \
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list,
                                        intptr_t index,
@@ skipping 18 matching lines @@
       ArgumentsDescriptor args_desc(
           Array::Handle(ArgumentsDescriptor::New(kNumArgs)));
       const Function& function = Function::Handle(Z,
           Resolver::ResolveDynamic(instance,
                                    Symbols::AssignIndexToken(),
                                    args_desc));
       if (!function.IsNull()) {
         const Integer& index_obj = Integer::Handle(Z, Integer::New(index));
         const Object& value_obj = Object::Handle(Z, Api::UnwrapHandle(value));
         if (!value_obj.IsNull() && !value_obj.IsInstance()) {
-          RETURN_TYPE_ERROR(I, value, Instance);
+          RETURN_TYPE_ERROR(Z, value, Instance);
         }
         const Array& args = Array::Handle(Z, Array::New(kNumArgs));
         args.SetAt(0, instance);
         args.SetAt(1, index_obj);
         args.SetAt(2, value_obj);
         return Api::NewHandle(I, DartEntry::InvokeFunction(function,
                                                                  args));
       }
     }
     return Api::NewError("Object does not implement the 'List' interface");
   }
 }
 
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
                                      const String& dotted_name,
                                      int num_args);
 
 
 static RawObject* ThrowArgumentError(const char* exception_message) {
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
+  Zone* zone = thread->zone();
   // Lookup the class ArgumentError in dart:core.
   const String& lib_url = String::Handle(String::New("dart:core"));
   const String& class_name = String::Handle(String::New("ArgumentError"));
   const Library& lib =
-      Library::Handle(isolate, Library::LookupLibrary(lib_url));
+      Library::Handle(zone, Library::LookupLibrary(lib_url));
   if (lib.IsNull()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: library '%s' not found.",
                              CURRENT_FUNC, lib_url.ToCString()));
     return ApiError::New(message);
   }
   const Class& cls = Class::Handle(
-      isolate, lib.LookupClassAllowPrivate(class_name));
+      zone, lib.LookupClassAllowPrivate(class_name));
   ASSERT(!cls.IsNull());
-  Object& result = Object::Handle(isolate);
+  Object& result = Object::Handle(zone);
   String& dot_name = String::Handle(String::New("."));
   String& constr_name = String::Handle(String::Concat(class_name, dot_name));
   result = ResolveConstructor(CURRENT_FUNC, cls, class_name, constr_name, 1);
   if (result.IsError()) return result.raw();
   ASSERT(result.IsFunction());
-  Function& constructor = Function::Handle(isolate);
+  Function& constructor = Function::Handle(zone);
   constructor ^= result.raw();
   if (!constructor.IsGenerativeConstructor()) {
     const String& message = String::Handle(
         String::NewFormatted("%s: class '%s' is not a constructor.",
                              CURRENT_FUNC, class_name.ToCString()));
     return ApiError::New(message);
   }
-  Instance& exception = Instance::Handle(isolate);
+  Instance& exception = Instance::Handle(zone);
   exception = Instance::New(cls);
-  const Array& args = Array::Handle(isolate, Array::New(3));
+  const Array& args = Array::Handle(zone, Array::New(3));
   args.SetAt(0, exception);
-  args.SetAt(1,
-             Smi::Handle(isolate, Smi::New(Function::kCtorPhaseAll)));
+  args.SetAt(1, Smi::Handle(zone, Smi::New(Function::kCtorPhaseAll)));
   args.SetAt(2, String::Handle(String::New(exception_message)));
   result = DartEntry::InvokeFunction(constructor, args);
   if (result.IsError()) return result.raw();
   ASSERT(result.IsNull());
 
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // throw an exception here.
     const String& message = String::Handle(
             String::New("No Dart frames on stack, cannot throw exception"));
@@ skipping 375 matching lines @@
 
 DART_EXPORT Dart_TypedData_Type Dart_GetTypeOfExternalTypedData(
     Dart_Handle object) {
   TRACE_API_CALL(CURRENT_FUNC);
   intptr_t class_id = Api::ClassId(object);
   if (RawObject::IsExternalTypedDataClassId(class_id)) {
     return GetType(class_id);
   }
   if (RawObject::IsTypedDataViewClassId(class_id)) {
     // Check if data object of the view is external.
-    Isolate* isolate = Isolate::Current();
-    const Instance& view_obj = Api::UnwrapInstanceHandle(isolate, object);
+    Zone* zone = Thread::Current()->zone();
+    const Instance& view_obj = Api::UnwrapInstanceHandle(zone, object);
     ASSERT(!view_obj.IsNull());
     const Instance& data_obj =
-        Instance::Handle(isolate, TypedDataView::Data(view_obj));
+        Instance::Handle(zone, TypedDataView::Data(view_obj));
     if (ExternalTypedData::IsExternalTypedData(data_obj)) {
       return GetType(class_id);
     }
   }
   return Dart_TypedData_kInvalid;
 }
 
 
-static RawObject* GetByteDataConstructor(Isolate* isolate,
+static RawObject* GetByteDataConstructor(Thread* thread,
                                          const String& constructor_name,
                                          intptr_t num_args) {
   const Library& lib =
-      Library::Handle(isolate->object_store()->typed_data_library());
+      Library::Handle(thread->isolate()->object_store()->typed_data_library());
   ASSERT(!lib.IsNull());
   const Class& cls = Class::Handle(
-      isolate, lib.LookupClassAllowPrivate(Symbols::ByteData()));
+      thread->zone(), lib.LookupClassAllowPrivate(Symbols::ByteData()));
   ASSERT(!cls.IsNull());
   return ResolveConstructor(CURRENT_FUNC,
                             cls,
                             Symbols::ByteData(),
                             constructor_name,
                             num_args);
 }
 
 
-static Dart_Handle NewByteData(Isolate* isolate, intptr_t length) {
+static Dart_Handle NewByteData(Thread* thread, intptr_t length) {
   CHECK_LENGTH(length, TypedData::MaxElements(kTypedDataInt8ArrayCid));
-  Object& result = Object::Handle(isolate);
-  result = GetByteDataConstructor(isolate, Symbols::ByteDataDot(), 1);
+  Isolate* isolate = thread->isolate();
+  Zone* zone = thread->zone();
+  Object& result = Object::Handle(zone);
+  result = GetByteDataConstructor(thread, Symbols::ByteDataDot(), 1);
   ASSERT(!result.IsNull());
   ASSERT(result.IsFunction());
   const Function& factory = Function::Cast(result);
   ASSERT(!factory.IsGenerativeConstructor());
 
   // Create the argument list.
-  const Array& args = Array::Handle(isolate, Array::New(2));
+  const Array& args = Array::Handle(zone, Array::New(2));
   // Factories get type arguments.
   args.SetAt(0, Object::null_type_arguments());
-  args.SetAt(1, Smi::Handle(isolate, Smi::New(length)));
+  args.SetAt(1, Smi::Handle(zone, Smi::New(length)));
 
   // Invoke the constructor and return the new object.
   result = DartEntry::InvokeFunction(factory, args);
   ASSERT(result.IsInstance() || result.IsNull() || result.IsError());
   return Api::NewHandle(isolate, result.raw());
 }
 
 
 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) {
+    Thread* thread, intptr_t cid, void* data, intptr_t length) {
   CHECK_LENGTH(length, ExternalTypedData::MaxElements(cid));
+  Isolate* isolate = thread->isolate();
+  Zone* zone = thread->zone();
   intptr_t bytes = length * ExternalTypedData::ElementSizeInBytes(cid);
   const ExternalTypedData& result = ExternalTypedData::Handle(
-      isolate,
+      zone,
       ExternalTypedData::New(cid,
                              reinterpret_cast<uint8_t*>(data),
                              length,
                              SpaceForExternal(isolate, bytes)));
   return Api::NewHandle(isolate, result.raw());
 }
 
 
 static Dart_Handle NewExternalByteData(
-    Isolate* isolate, void* data, intptr_t length) {
+    Thread* thread, void* data, intptr_t length) {
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
   Dart_Handle ext_data = NewExternalTypedData(
-      isolate, kExternalTypedDataUint8ArrayCid, data, length);
+      thread, kExternalTypedDataUint8ArrayCid, data, length);
   if (::Dart_IsError(ext_data)) {
     return ext_data;
   }
-  Object& result = Object::Handle(isolate);
-  result = GetByteDataConstructor(isolate, Symbols::ByteDataDot_view(), 3);
+  Object& result = Object::Handle(zone);
+  result = GetByteDataConstructor(thread, Symbols::ByteDataDot_view(), 3);
   ASSERT(!result.IsNull());
   ASSERT(result.IsFunction());
   const Function& factory = Function::Cast(result);
   ASSERT(!factory.IsGenerativeConstructor());
 
   // Create the argument list.
   const intptr_t num_args = 3;
-  const Array& args = Array::Handle(isolate, Array::New(num_args + 1));
+  const Array& args = Array::Handle(zone, Array::New(num_args + 1));
   // Factories get type arguments.
   args.SetAt(0, Object::null_type_arguments());
   const ExternalTypedData& array =
-      Api::UnwrapExternalTypedDataHandle(isolate, ext_data);
+      Api::UnwrapExternalTypedDataHandle(zone, ext_data);
   args.SetAt(1, array);
-  Smi& smi = Smi::Handle(isolate);
+  Smi& smi = Smi::Handle(zone);
   smi = Smi::New(0);
   args.SetAt(2, smi);
   smi = Smi::New(length);
   args.SetAt(3, smi);
 
   // Invoke the constructor and return the new object.
   result = DartEntry::InvokeFunction(factory, args);
   ASSERT(result.IsNull() || result.IsInstance() || result.IsError());
   return Api::NewHandle(isolate, result.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewTypedData(Dart_TypedData_Type type,
                                           intptr_t length) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
   switch (type) {
     case Dart_TypedData_kByteData :
-      return NewByteData(I, length);
+      return NewByteData(T, length);
     case Dart_TypedData_kInt8 :
       return NewTypedData(I, kTypedDataInt8ArrayCid, length);
     case Dart_TypedData_kUint8 :
       return NewTypedData(I, kTypedDataUint8ArrayCid, length);
     case Dart_TypedData_kUint8Clamped :
       return NewTypedData(I, kTypedDataUint8ClampedArrayCid, length);
     case Dart_TypedData_kInt16 :
       return NewTypedData(I, kTypedDataInt16ArrayCid, length);
     case Dart_TypedData_kUint16 :
       return NewTypedData(I, kTypedDataUint16ArrayCid, length);
@@ skipping 24 matching lines @@
     Dart_TypedData_Type type,
     void* data,
     intptr_t length) {
   DARTSCOPE(Thread::Current());
   if (data == NULL && length != 0) {
     RETURN_NULL_ERROR(data);
   }
   CHECK_CALLBACK_STATE(I);
   switch (type) {
     case Dart_TypedData_kByteData:
-      return NewExternalByteData(I, data, length);
+      return NewExternalByteData(T, data, length);
     case Dart_TypedData_kInt8:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataInt8ArrayCid, data, length);
     case Dart_TypedData_kUint8:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataUint8ArrayCid, data, length);
     case Dart_TypedData_kUint8Clamped:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataUint8ClampedArrayCid, data, length);
     case Dart_TypedData_kInt16:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataInt16ArrayCid, data, length);
     case Dart_TypedData_kUint16:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataUint16ArrayCid, data, length);
     case Dart_TypedData_kInt32:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataInt32ArrayCid, data, length);
     case Dart_TypedData_kUint32:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataUint32ArrayCid, data, length);
     case Dart_TypedData_kInt64:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataInt64ArrayCid, data, length);
     case Dart_TypedData_kUint64:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataUint64ArrayCid, data, length);
     case Dart_TypedData_kFloat32:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataFloat32ArrayCid, data, length);
     case Dart_TypedData_kFloat64:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataFloat64ArrayCid, data, length);
     case Dart_TypedData_kFloat32x4:
-      return NewExternalTypedData(I,
+      return NewExternalTypedData(T,
           kExternalTypedDataFloat32x4ArrayCid, data, length);
     default:
       return Api::NewError("%s expects argument 'type' to be of"
                            " 'external TypedData'", CURRENT_FUNC);
   }
   UNREACHABLE();
   return Api::Null();
 }
 
 
-static RawObject* GetByteBufferConstructor(Isolate* isolate,
+static RawObject* GetByteBufferConstructor(Thread* thread,
                                            const String& class_name,
                                            const String& constructor_name,
                                            intptr_t num_args) {
   const Library& lib =
-      Library::Handle(isolate->object_store()->typed_data_library());
+      Library::Handle(thread->isolate()->object_store()->typed_data_library());
   ASSERT(!lib.IsNull());
   const Class& cls = Class::Handle(
-      isolate, lib.LookupClassAllowPrivate(class_name));
+      thread->zone(), lib.LookupClassAllowPrivate(class_name));
   ASSERT(!cls.IsNull());
   return ResolveConstructor(CURRENT_FUNC,
                             cls,
                             class_name,
                             constructor_name,
                             num_args);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewByteBuffer(Dart_Handle typed_data) {
   DARTSCOPE(Thread::Current());
   intptr_t class_id = Api::ClassId(typed_data);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
       !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
-    RETURN_TYPE_ERROR(I, typed_data, 'TypedData');
+    RETURN_TYPE_ERROR(Z, typed_data, 'TypedData');
   }
   Object& result = Object::Handle(Z);
-  result = GetByteBufferConstructor(I,
+  result = GetByteBufferConstructor(T,
                                     Symbols::_ByteBuffer(),
                                     Symbols::_ByteBufferDot_New(),
                                     1);
   ASSERT(!result.IsNull());
   ASSERT(result.IsFunction());
   const Function& factory = Function::Cast(result);
   ASSERT(!factory.IsGenerativeConstructor());
 
   // Create the argument list.
   const Array& args = Array::Handle(Z, Array::New(2));
@@ skipping 44 matching lines @@
 
 DART_EXPORT Dart_Handle Dart_TypedDataAcquireData(Dart_Handle object,
                                                   Dart_TypedData_Type* type,
                                                   void** data,
                                                   intptr_t* len) {
   DARTSCOPE(Thread::Current());
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
       !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
-    RETURN_TYPE_ERROR(I, object, 'TypedData');
+    RETURN_TYPE_ERROR(Z, object, 'TypedData');
   }
   if (type == NULL) {
     RETURN_NULL_ERROR(type);
   }
   if (data == NULL) {
     RETURN_NULL_ERROR(data);
   }
   if (len == NULL) {
     RETURN_NULL_ERROR(len);
   }
   // Get the type of typed data object.
   *type = GetType(class_id);
   intptr_t length = 0;
   intptr_t size_in_bytes = 0;
   void* data_tmp = NULL;
   bool external = false;
   // If it is an external typed data object just return the data field.
   if (RawObject::IsExternalTypedDataClassId(class_id)) {
     const ExternalTypedData& obj =
-        Api::UnwrapExternalTypedDataHandle(I, object);
+        Api::UnwrapExternalTypedDataHandle(Z, object);
     ASSERT(!obj.IsNull());
     length = obj.Length();
     size_in_bytes = length * ExternalTypedData::ElementSizeInBytes(class_id);
     data_tmp = obj.DataAddr(0);
     external = true;
   } else if (RawObject::IsTypedDataClassId(class_id)) {
     // Regular typed data object, set up some GC and API callback guards.
-    const TypedData& obj = Api::UnwrapTypedDataHandle(I, object);
+    const TypedData& obj = Api::UnwrapTypedDataHandle(Z, object);
     ASSERT(!obj.IsNull());
     length = obj.Length();
     size_in_bytes = length * TypedData::ElementSizeInBytes(class_id);
     T->IncrementNoSafepointScopeDepth();
     START_NO_CALLBACK_SCOPE(I);
     data_tmp = obj.DataAddr(0);
   } else {
     ASSERT(RawObject::IsTypedDataViewClassId(class_id));
-    const Instance& view_obj = Api::UnwrapInstanceHandle(I, object);
+    const Instance& view_obj = Api::UnwrapInstanceHandle(Z, object);
     ASSERT(!view_obj.IsNull());
     Smi& val = Smi::Handle();
     val ^= TypedDataView::Length(view_obj);
     length = val.Value();
     size_in_bytes = length * TypedDataView::ElementSizeInBytes(class_id);
     val ^= TypedDataView::OffsetInBytes(view_obj);
     intptr_t offset_in_bytes = val.Value();
     const Instance& obj = Instance::Handle(TypedDataView::Data(view_obj));
     T->IncrementNoSafepointScopeDepth();
     START_NO_CALLBACK_SCOPE(I);
@@ skipping 31 matching lines @@
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_TypedDataReleaseData(Dart_Handle object) {
   DARTSCOPE(Thread::Current());
   intptr_t class_id = Api::ClassId(object);
   if (!RawObject::IsExternalTypedDataClassId(class_id) &&
       !RawObject::IsTypedDataViewClassId(class_id) &&
       !RawObject::IsTypedDataClassId(class_id)) {
-    RETURN_TYPE_ERROR(I, object, 'TypedData');
+    RETURN_TYPE_ERROR(Z, object, 'TypedData');
   }
   if (!RawObject::IsExternalTypedDataClassId(class_id)) {
     T->DecrementNoSafepointScopeDepth();
     END_NO_CALLBACK_SCOPE(I);
   }
   if (FLAG_verify_acquired_data) {
     const Object& obj = Object::Handle(Z, Api::UnwrapHandle(object));
     WeakTable* table = I->api_state()->acquired_table();
     intptr_t current = table->GetValue(obj.raw());
     if (current == 0) {
       return Api::NewError("Data was not acquired for this object.");
     }
     AcquiredData* ad = reinterpret_cast<AcquiredData*>(current);
     table->SetValue(obj.raw(), 0);  // Delete entry from table.
     delete ad;
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetDataFromByteBuffer(Dart_Handle object) {
-  Isolate* isolate = Isolate::Current();
+  Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   intptr_t class_id = Api::ClassId(object);
   if (class_id != kByteBufferCid) {
-    RETURN_TYPE_ERROR(isolate, object, 'ByteBuffer');
+    RETURN_TYPE_ERROR(zone, object, 'ByteBuffer');
   }
-  const Instance& instance = Api::UnwrapInstanceHandle(isolate, object);
+  const Instance& instance = Api::UnwrapInstanceHandle(zone, object);
   ASSERT(!instance.IsNull());
   return Api::NewHandle(isolate, ByteBuffer::Data(instance));
 }
 
 
 // ---  Invoking Constructors, Methods, and Field accessors ---
 
 static RawObject* ResolveConstructor(const char* current_func,
                                      const Class& cls,
                                      const String& class_name,
@@ skipping 52 matching lines @@
 
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
 
   // Get the class to instantiate.
   Object& unchecked_type = Object::Handle(Api::UnwrapHandle(type));
   if (unchecked_type.IsNull() || !unchecked_type.IsType()) {
-    RETURN_TYPE_ERROR(I, type, Type);
+    RETURN_TYPE_ERROR(Z, type, Type);
   }
   Type& type_obj = Type::Handle();
   type_obj ^= unchecked_type.raw();
   if (!type_obj.IsFinalized()) {
     return Api::NewError(
         "%s expects argument 'type' to be a fully resolved type.",
         CURRENT_FUNC);
   }
   Class& cls = Class::Handle(Z, type_obj.type_class());
   TypeArguments& type_arguments =
       TypeArguments::Handle(Z, type_obj.arguments());
 
   const String& base_constructor_name = String::Handle(Z, cls.Name());
 
   // And get the name of the constructor to invoke.
   String& dot_name = String::Handle(Z);
   result = Api::UnwrapHandle(constructor_name);
   if (result.IsNull()) {
     dot_name = Symbols::Dot().raw();
   } else if (result.IsString()) {
     dot_name = String::Concat(Symbols::Dot(), String::Cast(result));
   } else {
-    RETURN_TYPE_ERROR(I, constructor_name, String);
+    RETURN_TYPE_ERROR(Z, constructor_name, String);
   }
 
   // Resolve the constructor.
   String& constr_name =
       String::Handle(String::Concat(base_constructor_name, dot_name));
   result = ResolveConstructor("Dart_New",
                               cls,
                               base_constructor_name,
                               constr_name,
                               number_of_arguments);
@@ skipping 79 matching lines @@
   if (constructor.IsGenerativeConstructor()) {
     ASSERT(result.IsNull());
   } else {
     ASSERT(result.IsNull() || result.IsInstance());
     new_object ^= result.raw();
   }
   return Api::NewHandle(I, new_object.raw());
 }
 
 
-static RawInstance* AllocateObject(Isolate* isolate, const Class& cls) {
+static RawInstance* AllocateObject(Thread* thread, const Class& cls) {
   if (!cls.is_fields_marked_nullable()) {
     // Mark all fields as nullable.
-    Class& iterate_cls = Class::Handle(isolate, cls.raw());
-    Field& field = Field::Handle(isolate);
-    Array& fields = Array::Handle(isolate);
+    Zone* zone = thread->zone();
+    Class& iterate_cls = Class::Handle(zone, cls.raw());
+    Field& field = Field::Handle(zone);
+    Array& fields = Array::Handle(zone);
     while (!iterate_cls.IsNull()) {
       ASSERT(iterate_cls.is_finalized());
       iterate_cls.set_is_fields_marked_nullable();
       fields = iterate_cls.fields();
       iterate_cls = iterate_cls.SuperClass();
       for (int field_num = 0; field_num < fields.Length(); field_num++) {
         field ^= fields.At(field_num);
         if (field.is_static()) {
           continue;
         }
         field.RecordStore(Object::null_object());
       }
     }
   }
 
   // Allocate an object for the given class.
   return Instance::New(cls);
 }
 
 
 DART_EXPORT Dart_Handle Dart_Allocate(Dart_Handle type) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
 
-  const Type& type_obj = Api::UnwrapTypeHandle(I, type);
+  const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
   // Get the class to instantiate.
   if (type_obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, type, Type);
+    RETURN_TYPE_ERROR(Z, type, Type);
   }
   const Class& cls = Class::Handle(Z, type_obj.type_class());
   const Error& error = Error::Handle(Z, cls.EnsureIsFinalized(T));
   if (!error.IsNull()) {
     // An error occurred, return error object.
     return Api::NewHandle(I, error.raw());
   }
-  return Api::NewHandle(I, AllocateObject(I, cls));
+  return Api::NewHandle(I, AllocateObject(T, cls));
 }
 
 
 DART_EXPORT Dart_Handle Dart_AllocateWithNativeFields(
     Dart_Handle type,
     intptr_t num_native_fields,
     const intptr_t* native_fields) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
 
-  const Type& type_obj = Api::UnwrapTypeHandle(I, type);
+  const Type& type_obj = Api::UnwrapTypeHandle(Z, type);
   // Get the class to instantiate.
   if (type_obj.IsNull()) {
-    RETURN_TYPE_ERROR(I, type, Type);
+    RETURN_TYPE_ERROR(Z, type, Type);
   }
   if (native_fields == NULL) {
     RETURN_NULL_ERROR(native_fields);
   }
   const Class& cls = Class::Handle(Z, type_obj.type_class());
   const Error& error = Error::Handle(Z, cls.EnsureIsFinalized(T));
   if (!error.IsNull()) {
     // An error occurred, return error object.
     return Api::NewHandle(I, error.raw());
   }
   if (num_native_fields != cls.num_native_fields()) {
     return Api::NewError(
         "%s: invalid number of native fields %" Pd " passed in, expected %d",
         CURRENT_FUNC, num_native_fields, cls.num_native_fields());
   }
-  const Instance& instance = Instance::Handle(Z, AllocateObject(I, cls));
+  const Instance& instance = Instance::Handle(Z, AllocateObject(T, cls));
   instance.SetNativeFields(num_native_fields, native_fields);
   return Api::NewHandle(I, instance.raw());
 }
 
 
-static Dart_Handle SetupArguments(Isolate* isolate,
+static Dart_Handle SetupArguments(Thread* thread,
                                   int num_args,
                                   Dart_Handle* arguments,
                                   int extra_args,
                                   Array* args) {
+  Zone* zone = thread->zone();
+  Isolate* isolate = thread->isolate();
   // Check for malformed arguments in the arguments list.
   *args = Array::New(num_args + extra_args);
-  Object& arg = Object::Handle(isolate);
+  Object& arg = Object::Handle(zone);
   for (int i = 0; i < num_args; i++) {
     arg = Api::UnwrapHandle(arguments[i]);
     if (!arg.IsNull() && !arg.IsInstance()) {
       *args = Array::null();
       if (arg.IsError()) {
         return Api::NewHandle(isolate, arg.raw());
       } else {
         return Api::NewError(
             "%s expects arguments[%d] to be an Instance handle.",
             "Dart_Invoke", i);
@@ skipping 10 matching lines @@
                                                int number_of_arguments,
                                                Dart_Handle* arguments) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
 
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
-  const String& constructor_name = Api::UnwrapStringHandle(I, name);
+  const String& constructor_name = Api::UnwrapStringHandle(Z, name);
   if (constructor_name.IsNull()) {
-    RETURN_TYPE_ERROR(I, name, String);
+    RETURN_TYPE_ERROR(Z, name, String);
   }
-  const Instance& instance = Api::UnwrapInstanceHandle(I, object);
+  const Instance& instance = Api::UnwrapInstanceHandle(Z, object);
   if (instance.IsNull()) {
-    RETURN_TYPE_ERROR(I, object, Instance);
+    RETURN_TYPE_ERROR(Z, object, Instance);
   }
 
   // Since we have allocated an object it would mean that the type
   // is finalized.
   // TODO(asiva): How do we ensure that a constructor is not called more than
   // once for the same object.
 
   // Construct name of the constructor to invoke.
   const Type& type_obj = Type::Handle(Z, instance.GetType());
   const Class& cls = Class::Handle(Z, type_obj.type_class());
@@ skipping 17 matching lines @@
     // Constructors get the uninitialized object and a constructor phase.
     if (!type_arguments.IsNull()) {
       // The type arguments will be null if the class has no type
       // parameters, in which case the following call would fail
       // because there is no slot reserved in the object for the
       // type vector.
       instance.SetTypeArguments(type_arguments);
     }
     Dart_Handle result;
     Array& args = Array::Handle(Z);
-    result = SetupArguments(I,
+    result = SetupArguments(T,
         number_of_arguments, arguments, extra_args, &args);
     if (!::Dart_IsError(result)) {
       args.SetAt(0, instance);
       args.SetAt(1, Smi::Handle(Z, Smi::New(Function::kCtorPhaseAll)));
       const Object& retval = Object::Handle(Z,
           DartEntry::InvokeFunction(constructor, args));
       if (retval.IsError()) {
         result = Api::NewHandle(I, retval.raw());
       } else {
         result = Api::NewHandle(I, instance.raw());
       }
     }
     return result;
   }
   return Api::NewError(
       "%s expects argument 'name' to be a valid constructor.",
       CURRENT_FUNC);
 }
 
 
 DART_EXPORT Dart_Handle Dart_Invoke(Dart_Handle target,
                                     Dart_Handle name,
                                     int number_of_arguments,
                                     Dart_Handle* arguments) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
 
-  const String& function_name = Api::UnwrapStringHandle(I, name);
+  const String& function_name = Api::UnwrapStringHandle(Z, name);
   if (function_name.IsNull()) {
-    RETURN_TYPE_ERROR(I, name, String);
+    RETURN_TYPE_ERROR(Z, name, String);
   }
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(target));
   if (obj.IsError()) {
     return target;
   }
@@ skipping 13 matching lines @@
                                             number_of_arguments,
                                             Object::empty_array()));
     if (function.IsNull()) {
       const String& cls_name = String::Handle(Z, cls.Name());
       return Api::NewError("%s: did not find static method '%s.%s'.",
                            CURRENT_FUNC,
                            cls_name.ToCString(),
                            function_name.ToCString());
     }
     // Setup args and check for malformed arguments in the arguments list.
-    result = SetupArguments(I, number_of_arguments, arguments, 0, &args);
+    result = SetupArguments(T, number_of_arguments, arguments, 0, &args);
     if (!::Dart_IsError(result)) {
       result = Api::NewHandle(I, DartEntry::InvokeFunction(function, args));
     }
     return result;
   } else if (obj.IsNull() || obj.IsInstance()) {
     // Since we have allocated an object it would mean that the type of the
     // receiver is already resolved and finalized, hence it is not necessary
     // to check here.
     Instance& instance = Instance::Handle(Z);
     instance ^= obj.raw();
     ArgumentsDescriptor args_desc(
         Array::Handle(Z, ArgumentsDescriptor::New(number_of_arguments + 1)));
     const Function& function = Function::Handle(Z,
         Resolver::ResolveDynamic(instance, function_name, args_desc));
     if (function.IsNull()) {
       // Setup args and check for malformed arguments in the arguments list.
-      result = SetupArguments(I,
+      result = SetupArguments(T,
                               number_of_arguments,
                               arguments,
                               1,
                               &args);
       if (!::Dart_IsError(result)) {
         args.SetAt(0, instance);
         const Array& args_descriptor =
           Array::Handle(Z, ArgumentsDescriptor::New(args.Length()));
         result = Api::NewHandle(I,
                                 DartEntry::InvokeNoSuchMethod(instance,
                                                               function_name,
                                                               args,
                                                               args_descriptor));
       }
       return result;
     }
     // Setup args and check for malformed arguments in the arguments list.
-    result = SetupArguments(I, number_of_arguments, arguments, 1, &args);
+    result = SetupArguments(T, number_of_arguments, arguments, 1, &args);
     if (!::Dart_IsError(result)) {
       args.SetAt(0, instance);
       result = Api::NewHandle(I, DartEntry::InvokeFunction(function, args));
     }
     return result;
   } else if (obj.IsLibrary()) {
     // Check whether class finalization is needed.
     const Library& lib = Library::Cast(obj);
 
     // Check that the library is loaded.
@@ skipping 15 matching lines @@
     String& error_message = String::Handle(Z);
     if (!function.AreValidArgumentCounts(number_of_arguments,
                                          0,
                                          &error_message)) {
       return Api::NewError("%s: wrong argument count for function '%s': %s.",
                            CURRENT_FUNC,
                            function_name.ToCString(),
                            error_message.ToCString());
     }
     // Setup args and check for malformed arguments in the arguments list.
-    result = SetupArguments(I, number_of_arguments, arguments, 0, &args);
+    result = SetupArguments(T, number_of_arguments, arguments, 0, &args);
     if (!::Dart_IsError(result)) {
       result = Api::NewHandle(I, DartEntry::InvokeFunction(function, args));
     }
     return result;
   } else {
     return Api::NewError(
         "%s expects argument 'target' to be an object, type, or library.",
         CURRENT_FUNC);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
-  const Instance& closure_obj = Api::UnwrapInstanceHandle(I, closure);
+  const Instance& closure_obj = Api::UnwrapInstanceHandle(Z, closure);
   if (closure_obj.IsNull() || !closure_obj.IsCallable(NULL)) {
-    RETURN_TYPE_ERROR(I, closure, Instance);
+    RETURN_TYPE_ERROR(Z, closure, Instance);
   }
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
 
   // Set up arguments to include the closure as the first argument.
   const Array& args = Array::Handle(Z, Array::New(number_of_arguments + 1));
   Object& obj = Object::Handle(Z);
   args.SetAt(0, closure_obj);
   for (int i = 0; i < number_of_arguments; i++) {
     obj = Api::UnwrapHandle(arguments[i]);
     if (!obj.IsNull() && !obj.IsInstance()) {
-      RETURN_TYPE_ERROR(I, arguments[i], Instance);
+      RETURN_TYPE_ERROR(Z, arguments[i], Instance);
     }
     args.SetAt(i + 1, obj);
   }
   // Now try to invoke the closure.
   return Api::NewHandle(I, DartEntry::InvokeClosure(args));
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetField(Dart_Handle container, Dart_Handle name) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
 
-  const String& field_name = Api::UnwrapStringHandle(I, name);
+  const String& field_name = Api::UnwrapStringHandle(Z, name);
   if (field_name.IsNull()) {
-    RETURN_TYPE_ERROR(I, name, String);
+    RETURN_TYPE_ERROR(Z, name, String);
   }
 
   Field& field = Field::Handle(Z);
   Function& getter = Function::Handle(Z);
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(container));
   if (obj.IsNull()) {
     return Api::NewError("%s expects argument 'container' to be non-null.",
                          CURRENT_FUNC);
   } else if (obj.IsType()) {
     if (!Type::Cast(obj).IsFinalized()) {
@@ skipping 98 matching lines @@
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetField(Dart_Handle container,
                                       Dart_Handle name,
                                       Dart_Handle value) {
   DARTSCOPE(Thread::Current());
   CHECK_CALLBACK_STATE(I);
 
-  const String& field_name = Api::UnwrapStringHandle(I, name);
+  const String& field_name = Api::UnwrapStringHandle(Z, name);
   if (field_name.IsNull()) {
-    RETURN_TYPE_ERROR(I, name, String);
+    RETURN_TYPE_ERROR(Z, name, String);
   }
 
   // Since null is allowed for value, we don't use UnwrapInstanceHandle.
   const Object& value_obj = Object::Handle(Z, Api::UnwrapHandle(value));
   if (!value_obj.IsNull() && !value_obj.IsInstance()) {
-    RETURN_TYPE_ERROR(I, value, Instance);
+    RETURN_TYPE_ERROR(Z, value, Instance);
   }
   Instance& value_instance = Instance::Handle(Z);
   value_instance ^= value_obj.raw();
 
   Field& field = Field::Handle(Z);
   Function& setter = Function::Handle(Z);
   const Object& obj = Object::Handle(Z, Api::UnwrapHandle(container));
   if (obj.IsNull()) {
     return Api::NewError("%s expects argument 'container' to be non-null.",
                          CURRENT_FUNC);
@@ skipping 121 matching lines @@
   return Api::NewError(
       "%s expects argument 'container' to be an object, type, or library.",
       CURRENT_FUNC);
 }
 
 
 // --- Exceptions ----
 
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
   Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   {
-    const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
+    const Instance& excp = Api::UnwrapInstanceHandle(zone, exception);
     if (excp.IsNull()) {
-      RETURN_TYPE_ERROR(isolate, exception, Instance);
+      RETURN_TYPE_ERROR(zone, exception, Instance);
     }
   }
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // throw an exception here.
     return Api::NewError("No Dart frames on stack, cannot throw exception");
   }
 
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Instance* saved_exception;
   {
     NoSafepointScope no_safepoint;
     RawInstance* raw_exception =
-        Api::UnwrapInstanceHandle(isolate, exception).raw();
+        Api::UnwrapInstanceHandle(zone, exception).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
   }
   Exceptions::Throw(thread, *saved_exception);
   return Api::NewError("Exception was not thrown, internal error");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace) {
   Thread* thread = Thread::Current();
+  Zone* zone = thread->zone();
   Isolate* isolate = thread->isolate();
   CHECK_ISOLATE(isolate);
   CHECK_CALLBACK_STATE(isolate);
   {
-    const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
+    const Instance& excp = Api::UnwrapInstanceHandle(zone, exception);
     if (excp.IsNull()) {
-      RETURN_TYPE_ERROR(isolate, exception, Instance);
+      RETURN_TYPE_ERROR(zone, exception, Instance);
     }
-    const Instance& stk = Api::UnwrapInstanceHandle(isolate, stacktrace);
+    const Instance& stk = Api::UnwrapInstanceHandle(zone, stacktrace);
     if (stk.IsNull()) {
-      RETURN_TYPE_ERROR(isolate, stacktrace, Instance);
+      RETURN_TYPE_ERROR(zone, stacktrace, Instance);
     }
   }
   if (isolate->top_exit_frame_info() == 0) {
     // There are no dart frames on the stack so it would be illegal to
     // throw an exception here.
     return Api::NewError("No Dart frames on stack, cannot throw exception");
   }
 
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Instance* saved_exception;
   const Stacktrace* saved_stacktrace;
   {
     NoSafepointScope no_safepoint;
     RawInstance* raw_exception =
-        Api::UnwrapInstanceHandle(isolate, exception).raw();
+        Api::UnwrapInstanceHandle(zone, exception).raw();
     RawStacktrace* raw_stacktrace =
-        Api::UnwrapStacktraceHandle(isolate, stacktrace).raw();
+        Api::UnwrapStacktraceHandle(zone, stacktrace).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
     saved_stacktrace = &Stacktrace::Handle(raw_stacktrace);
   }
   Exceptions::ReThrow(thread, *saved_exception, *saved_stacktrace);
   return Api::NewError("Exception was not re thrown, internal error");
 }
 
 
 // --- Native fields and functions ---
 
 DART_EXPORT Dart_Handle Dart_CreateNativeWrapperClass(Dart_Handle library,
                                                       Dart_Handle name,
                                                       int field_count) {
   DARTSCOPE(Thread::Current());
-  const String& cls_name = Api::UnwrapStringHandle(I, name);
+  const String& cls_name = Api::UnwrapStringHandle(Z, name);
   if (cls_name.IsNull()) {
-    RETURN_TYPE_ERROR(I, name, String);
+    RETURN_TYPE_ERROR(Z, name, String);
   }
-  const Library& lib = Api::UnwrapLibraryHandle(I, library);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
   if (!Utils::IsUint(16, field_count)) {
     return Api::NewError(
         "Invalid field_count passed to Dart_CreateNativeWrapperClass");
   }
   CHECK_CALLBACK_STATE(I);
 
   String& cls_symbol = String::Handle(Z, Symbols::New(cls_name));
   const Class& cls = Class::Handle(Z,
       Class::NewNativeWrapper(lib, cls_symbol, field_count));
   if (cls.IsNull()) {
     return Api::NewError(
         "Unable to create native wrapper class : already exists");
   }
   return Api::NewHandle(I, cls.RareType());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceFieldCount(Dart_Handle obj,
                                                          int* count) {
   Thread* thread = Thread::Current();
   CHECK_ISOLATE(thread->isolate());
   ReusableObjectHandleScope reused_obj_handle(thread);
   const Instance& instance = Api::UnwrapInstanceHandle(reused_obj_handle, obj);
   if (instance.IsNull()) {
-    RETURN_TYPE_ERROR(thread->isolate(), obj, Instance);
+    RETURN_TYPE_ERROR(thread->zone(), obj, Instance);
   }
   *count = instance.NumNativeFields();
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t* value) {
   Thread* thread = Thread::Current();
   CHECK_ISOLATE(thread->isolate());
   ReusableObjectHandleScope reused_obj_handle(thread);
   const Instance& instance = Api::UnwrapInstanceHandle(reused_obj_handle, obj);
   if (instance.IsNull()) {
-    RETURN_TYPE_ERROR(thread->isolate(), obj, Instance);
+    RETURN_TYPE_ERROR(thread->zone(), 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) {
   DARTSCOPE(Thread::Current());
-  const Instance& instance = Api::UnwrapInstanceHandle(I, obj);
+  const Instance& instance = Api::UnwrapInstanceHandle(Z, obj);
   if (instance.IsNull()) {
-    RETURN_TYPE_ERROR(I, obj, Instance);
+    RETURN_TYPE_ERROR(Z, 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 290 matching lines @@
           isolate->api_state()->IsValidPrologueWeakPersistentHandle(rval)));
 #endif
   Api::SetWeakHandleReturnValue(arguments, rval);
 }
 
 
 // --- Environment ---
 RawString* Api::CallEnvironmentCallback(Isolate* isolate, const String& name) {
   Scope api_scope(isolate);
   Dart_EnvironmentCallback callback = isolate->environment_callback();
-  String& result = String::Handle(isolate);
+  String& result = String::Handle(isolate->current_zone());
   if (callback != NULL) {
     Dart_Handle response = callback(Api::NewHandle(isolate, name.raw()));
     if (::Dart_IsString(response)) {
       result ^= Api::UnwrapHandle(response);
     } else if (::Dart_IsError(response)) {
       const Object& error =
-          Object::Handle(isolate, Api::UnwrapHandle(response));
+          Object::Handle(isolate->current_zone(), Api::UnwrapHandle(response));
       Exceptions::ThrowArgumentError(
           String::Handle(String::New(Error::Cast(error).ToErrorCString())));
     } else if (!::Dart_IsNull(response)) {
       // At this point everything except null are invalid environment values.
       Exceptions::ThrowArgumentError(
           String::Handle(String::New("Illegal environment value")));
     }
   }
   if (result.IsNull()) {
     // TODO(iposva): Determine whether builtin values can be overriden by the
@@ skipping 69 matching lines @@
 static void CompileSource(Isolate* isolate,
                           const Library& lib,
                           const Script& script,
                           Dart_Handle* result) {
   bool update_lib_status = (script.kind() == RawScript::kScriptTag ||
                             script.kind() == RawScript::kLibraryTag);
   if (update_lib_status) {
     lib.SetLoadInProgress();
   }
   ASSERT(isolate != NULL);
-  const Error& error = Error::Handle(isolate, Compiler::Compile(lib, script));
+  const Error& error =
+      Error::Handle(isolate->current_zone(), Compiler::Compile(lib, script));
   if (error.IsNull()) {
     *result = Api::NewHandle(isolate, lib.raw());
   } else {
     *result = Api::NewHandle(isolate, error.raw());
     // Compilation errors are not Dart instances, so just mark the library
     // as having failed to load without providing an error instance.
     lib.SetLoadError(Object::null_instance());
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadScript(Dart_Handle url,
                                         Dart_Handle source,
                                         intptr_t line_offset,
                                         intptr_t column_offset) {
   DARTSCOPE(Thread::Current());
-  const String& url_str = Api::UnwrapStringHandle(I, url);
+  const String& url_str = Api::UnwrapStringHandle(Z, url);
   if (url_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, url, String);
+    RETURN_TYPE_ERROR(Z, url, String);
   }
-  const String& source_str = Api::UnwrapStringHandle(I, source);
+  const String& source_str = Api::UnwrapStringHandle(Z, source);
   if (source_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, source, String);
+    RETURN_TYPE_ERROR(Z, source, String);
   }
   Library& library = Library::Handle(Z, I->object_store()->root_library());
   if (!library.IsNull()) {
     const String& library_url = String::Handle(Z, library.url());
     return Api::NewError("%s: A script has already been loaded from '%s'.",
                          CURRENT_FUNC, library_url.ToCString());
   }
   if (line_offset < 0) {
     return Api::NewError("%s: argument 'line_offset' must be positive number",
                          CURRENT_FUNC);
@@ skipping 65 matching lines @@
 DART_EXPORT Dart_Handle Dart_RootLibrary() {
   Isolate* isolate = Isolate::Current();
   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) {
   DARTSCOPE(Thread::Current());
-  const Library& lib = Api::UnwrapLibraryHandle(I, library);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
-  const String& cls_name = Api::UnwrapStringHandle(I, class_name);
+  const String& cls_name = Api::UnwrapStringHandle(Z, class_name);
   if (cls_name.IsNull()) {
-    RETURN_TYPE_ERROR(I, class_name, String);
+    RETURN_TYPE_ERROR(Z, class_name, String);
   }
   const Class& cls = Class::Handle(Z, lib.LookupClassAllowPrivate(cls_name));
   if (cls.IsNull()) {
     // TODO(turnidge): Return null or error in this case?
     const String& lib_name = String::Handle(Z, lib.name());
     return Api::NewError("Class '%s' not found in library '%s'.",
                          cls_name.ToCString(), lib_name.ToCString());
   }
   return Api::NewHandle(I, cls.RareType());
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetType(Dart_Handle library,
                                      Dart_Handle class_name,
                                      intptr_t number_of_type_arguments,
                                      Dart_Handle* type_arguments) {
   DARTSCOPE(Thread::Current());
 
   // Validate the input arguments.
-  const Library& lib = Api::UnwrapLibraryHandle(I, library);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
   if (!lib.Loaded()) {
     return Api::NewError(
         "%s expects library argument 'library' to be loaded.",
         CURRENT_FUNC);
   }
-  const String& name_str = Api::UnwrapStringHandle(I, class_name);
+  const String& name_str = Api::UnwrapStringHandle(Z, class_name);
   if (name_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, class_name, String);
+    RETURN_TYPE_ERROR(Z, class_name, String);
   }
   const Class& cls = Class::Handle(Z, lib.LookupClassAllowPrivate(name_str));
   if (cls.IsNull()) {
     const String& lib_name = String::Handle(Z, lib.name());
     return Api::NewError("Type '%s' not found in library '%s'.",
                          name_str.ToCString(), lib_name.ToCString());
   }
   if (cls.NumTypeArguments() == 0) {
     if (number_of_type_arguments != 0) {
       return Api::NewError("Invalid number of type arguments specified, "
                            "got %" Pd " expected 0", number_of_type_arguments);
     }
     return Api::NewHandle(I, Type::NewNonParameterizedType(cls));
   }
   intptr_t num_expected_type_arguments = cls.NumTypeParameters();
   TypeArguments& type_args_obj = TypeArguments::Handle();
   if (number_of_type_arguments > 0) {
     if (type_arguments == NULL) {
       RETURN_NULL_ERROR(type_arguments);
     }
     if (num_expected_type_arguments != number_of_type_arguments) {
       return Api::NewError("Invalid number of type arguments specified, "
                            "got %" Pd " expected %" Pd,
                            number_of_type_arguments,
                            num_expected_type_arguments);
     }
-    const Array& array = Api::UnwrapArrayHandle(I, *type_arguments);
+    const Array& array = Api::UnwrapArrayHandle(Z, *type_arguments);
     if (array.IsNull()) {
-      RETURN_TYPE_ERROR(I, *type_arguments, Array);
+      RETURN_TYPE_ERROR(Z, *type_arguments, Array);
     }
     if (array.Length() != num_expected_type_arguments) {
       return Api::NewError("Invalid type arguments specified, expected an "
                            "array of len %" Pd " but got an array of len %" Pd,
                            number_of_type_arguments,
                            array.Length());
     }
     // Set up the type arguments array.
     type_args_obj ^= TypeArguments::New(num_expected_type_arguments);
     AbstractType& type_arg = AbstractType::Handle();
     for (intptr_t i = 0; i < number_of_type_arguments; i++) {
       type_arg ^= array.At(i);
       type_args_obj.SetTypeAt(i, type_arg);
     }
   }
 
   // Construct the type object, canonicalize it and return.
   Type& instantiated_type = Type::Handle(
       Type::New(cls, type_args_obj, Scanner::kNoSourcePos));
   instantiated_type ^= ClassFinalizer::FinalizeType(
       cls, instantiated_type, ClassFinalizer::kCanonicalize);
   return Api::NewHandle(I, instantiated_type.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library) {
   DARTSCOPE(Thread::Current());
-  const Library& lib = Api::UnwrapLibraryHandle(I, library);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
   const String& url = String::Handle(Z, lib.url());
   ASSERT(!url.IsNull());
   return Api::NewHandle(I, url.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url) {
   DARTSCOPE(Thread::Current());
-  const String& url_str = Api::UnwrapStringHandle(I, url);
+  const String& url_str = Api::UnwrapStringHandle(Z, url);
   if (url_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, url, String);
+    RETURN_TYPE_ERROR(Z, url, String);
   }
   const Library& library = Library::Handle(Z, Library::LookupLibrary(url_str));
   if (library.IsNull()) {
     return Api::NewError("%s: library '%s' not found.",
                          CURRENT_FUNC, url_str.ToCString());
   } else {
     return Api::NewHandle(I, library.raw());
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryHandleError(Dart_Handle library_in,
                                                 Dart_Handle error_in) {
   DARTSCOPE(Thread::Current());
 
-  const Library& lib = Api::UnwrapLibraryHandle(I, library_in);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library_in);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library_in, Library);
+    RETURN_TYPE_ERROR(Z, library_in, Library);
   }
-  const Instance& err = Api::UnwrapInstanceHandle(I, error_in);
+  const Instance& err = Api::UnwrapInstanceHandle(Z, error_in);
   if (err.IsNull()) {
-    RETURN_TYPE_ERROR(I, error_in, Instance);
+    RETURN_TYPE_ERROR(Z, error_in, Instance);
   }
   CHECK_CALLBACK_STATE(I);
 
   const GrowableObjectArray& pending_deferred_loads =
       GrowableObjectArray::Handle(Z,
           I->object_store()->pending_deferred_loads());
   for (intptr_t i = 0; i < pending_deferred_loads.Length(); i++) {
     if (pending_deferred_loads.At(i) == lib.raw()) {
       lib.SetLoadError(err);
       return Api::Null();
     }
   }
   return error_in;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadLibrary(Dart_Handle url,
                                          Dart_Handle source,
                                          intptr_t line_offset,
                                          intptr_t column_offset) {
   DARTSCOPE(Thread::Current());
-  const String& url_str = Api::UnwrapStringHandle(I, url);
+  const String& url_str = Api::UnwrapStringHandle(Z, url);
   if (url_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, url, String);
+    RETURN_TYPE_ERROR(Z, url, String);
   }
-  const String& source_str = Api::UnwrapStringHandle(I, source);
+  const String& source_str = Api::UnwrapStringHandle(Z, source);
   if (source_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, source, String);
+    RETURN_TYPE_ERROR(Z, source, String);
   }
   if (line_offset < 0) {
     return Api::NewError("%s: argument 'line_offset' must be positive number",
                          CURRENT_FUNC);
   }
   if (column_offset < 0) {
     return Api::NewError("%s: argument 'column_offset' must be positive number",
                          CURRENT_FUNC);
   }
   CHECK_CALLBACK_STATE(I);
@@ skipping 32 matching lines @@
     }
   }
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryImportLibrary(Dart_Handle library,
                                                   Dart_Handle import,
                                                   Dart_Handle prefix) {
   DARTSCOPE(Thread::Current());
-  const Library& library_vm = Api::UnwrapLibraryHandle(I, library);
+  const Library& library_vm = Api::UnwrapLibraryHandle(Z, library);
   if (library_vm.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
-  const Library& import_vm = Api::UnwrapLibraryHandle(I, import);
+  const Library& import_vm = Api::UnwrapLibraryHandle(Z, import);
   if (import_vm.IsNull()) {
-    RETURN_TYPE_ERROR(I, import, Library);
+    RETURN_TYPE_ERROR(Z, import, Library);
   }
   const Object& prefix_object = Object::Handle(Z, Api::UnwrapHandle(prefix));
   const String& prefix_vm = prefix_object.IsNull()
       ? Symbols::Empty()
       : String::Cast(prefix_object);
   if (prefix_vm.IsNull()) {
-    RETURN_TYPE_ERROR(I, prefix, String);
+    RETURN_TYPE_ERROR(Z, prefix, String);
   }
   CHECK_CALLBACK_STATE(I);
   CHECK_COMPILATION_ALLOWED(I);
 
   const String& prefix_symbol = String::Handle(Z, Symbols::New(prefix_vm));
   const Namespace& import_ns = Namespace::Handle(Z,
       Namespace::New(import_vm, Object::null_array(), Object::null_array()));
   if (prefix_vm.Length() == 0) {
     library_vm.AddImport(import_ns);
   } else {
@@ skipping 10 matching lines @@
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadSource(Dart_Handle library,
                                         Dart_Handle url,
                                         Dart_Handle source,
                                         intptr_t line_offset,
                                         intptr_t column_offset) {
   DARTSCOPE(Thread::Current());
-  const Library& lib = Api::UnwrapLibraryHandle(I, library);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
-  const String& url_str = Api::UnwrapStringHandle(I, url);
+  const String& url_str = Api::UnwrapStringHandle(Z, url);
   if (url_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, url, String);
+    RETURN_TYPE_ERROR(Z, url, String);
   }
-  const String& source_str = Api::UnwrapStringHandle(I, source);
+  const String& source_str = Api::UnwrapStringHandle(Z, source);
   if (source_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, source, String);
+    RETURN_TYPE_ERROR(Z, source, String);
   }
   if (line_offset < 0) {
     return Api::NewError("%s: argument 'line_offset' must be positive number",
                          CURRENT_FUNC);
   }
   if (column_offset < 0) {
     return Api::NewError("%s: argument 'column_offset' must be positive number",
                          CURRENT_FUNC);
   }
   CHECK_CALLBACK_STATE(I);
   CHECK_COMPILATION_ALLOWED(I);
 
   NoHeapGrowthControlScope no_growth_control;
 
   const Script& script = Script::Handle(Z,
       Script::New(url_str, source_str, RawScript::kSourceTag));
   script.SetLocationOffset(line_offset, column_offset);
   Dart_Handle result;
   CompileSource(I, lib, script, &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryLoadPatch(Dart_Handle library,
                                               Dart_Handle url,
                                               Dart_Handle patch_source) {
   DARTSCOPE(Thread::Current());
-  const Library& lib = Api::UnwrapLibraryHandle(I, library);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
-  const String& url_str = Api::UnwrapStringHandle(I, url);
+  const String& url_str = Api::UnwrapStringHandle(Z, url);
   if (url_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, url, String);
+    RETURN_TYPE_ERROR(Z, url, String);
   }
-  const String& source_str = Api::UnwrapStringHandle(I, patch_source);
+  const String& source_str = Api::UnwrapStringHandle(Z, patch_source);
   if (source_str.IsNull()) {
-    RETURN_TYPE_ERROR(I, patch_source, String);
+    RETURN_TYPE_ERROR(Z, patch_source, String);
   }
   CHECK_CALLBACK_STATE(I);
   CHECK_COMPILATION_ALLOWED(I);
 
   NoHeapGrowthControlScope no_growth_control;
 
   const Script& script = Script::Handle(Z,
       Script::New(url_str, source_str, RawScript::kPatchTag));
   Dart_Handle result;
   CompileSource(I, lib, script, &result);
@@ skipping 50 matching lines @@
   }
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetNativeResolver(
     Dart_Handle library,
     Dart_NativeEntryResolver resolver,
     Dart_NativeEntrySymbol symbol) {
   DARTSCOPE(Thread::Current());
-  const Library& lib = Api::UnwrapLibraryHandle(I, library);
+  const Library& lib = Api::UnwrapLibraryHandle(Z, library);
   if (lib.IsNull()) {
-    RETURN_TYPE_ERROR(I, library, Library);
+    RETURN_TYPE_ERROR(Z, library, Library);
   }
   lib.set_native_entry_resolver(resolver);
   lib.set_native_entry_symbol_resolver(symbol);
   return Api::Success();
 }
 
 
 // --- Peer support ---
 
 DART_EXPORT Dart_Handle Dart_GetPeer(Dart_Handle object, void** peer) {
@@ skipping 527 matching lines @@
                                    ApiReallocate);
   writer.WriteFullSnapshot();
   *vm_isolate_snapshot_size = writer.VmIsolateSnapshotSize();
   *isolate_snapshot_size = writer.IsolateSnapshotSize();
   *instructions_snapshot_size = writer.InstructionsSnapshotSize();
 
   return Api::Success();
 }
 
 }  // namespace dart