Changes to pass the current isolate to all runtime and native calls.

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 37 matching lines @@
     } else if (tmp.IsApiFailure()) {                                          \
       return dart_handle;                                                     \
     } else {                                                                  \
       return Api::Error("%s expects argument '%s' to be of type %s.",         \
                         CURRENT_FUNC, #dart_handle, #Type);                   \
     }                                                                         \
   } while (0)
 
 
 DART_EXPORT bool Dart_IsValid(const Dart_Handle& handle) {
-  ASSERT(Isolate::Current() != NULL);
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
 
   // Make sure that the object isn't an ApiFailure.
   const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
   return !obj.IsApiFailure();
 }
 
 
 DART_EXPORT void _Dart_ReportInvalidHandle(const char* file,
                                            int line,
                                            const char* handle,
                                            const char* message) {
   fprintf(stderr, "%s:%d: invalid handle: '%s':\n    '%s'\n",
           file, line, handle, message);
   OS::Abort();
 }
 
 
 DART_EXPORT const char* Dart_GetError(const Dart_Handle& handle) {
-  ASSERT(Isolate::Current() != NULL);
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+
   const Object& obj = Object::Handle(Api::UnwrapHandle(handle));
   if (!obj.IsApiFailure()) {
     return "";
   }
   ApiFailure& failure = ApiFailure::Handle();
   failure ^= obj.raw();
   const String& message = String::Handle(failure.message());
   const char* msg = message.ToCString();
   intptr_t len = strlen(msg) + 1;
   char* msg_copy = reinterpret_cast<char*>(Api::Allocate(len));
   OS::SNPrint(msg_copy, len, "%s", msg);
   return msg_copy;
 }
 
 
 // TODO(turnidge): This clonse Api::Error.  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, ...) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  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);
@@ skipping 20 matching lines @@
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     Dart::InitializeIsolate(snapshot, data);
     START_TIMER(time_total_runtime);
     isolate->set_long_jump_base(base);
     return reinterpret_cast<Dart_Isolate>(isolate);
   } else {
     {
-      Zone zone;  // Setup a VM zone as we are creating some handles.
-      HandleScope scope;  // Setup a VM handle scope.
+      DARTSCOPE(isolate);
       const String& error =
-          String::Handle(Isolate::Current()->object_store()->sticky_error());
+          String::Handle(isolate->object_store()->sticky_error());
       // TODO(asiva): Need to return this as a error.
       OS::PrintErr(error.ToCString());
     }
     Dart::ShutdownIsolate();
   }
   return reinterpret_cast<Dart_Isolate>(NULL);
 }
 
 
 DART_EXPORT void Dart_ShutdownIsolate() {
@@ skipping 66 matching lines @@
   strtmp = DartLibraryCalls::ToString(stack);
   str = strtmp.ToCString();
   fprintf(stderr, "%s\n", str);
   exit(255);
 }
 
 
 DART_EXPORT void Dart_HandleMessage(Dart_Port dest_port,
                                     Dart_Port reply_port,
                                     Dart_Message dart_message) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
+
   const Instance& msg = Instance::Handle(DeserializeMessage(dart_message));
   const String& class_name =
       String::Handle(String::NewSymbol("ReceivePortImpl"));
   const String& function_name =
       String::Handle(String::NewSymbol("handleMessage_"));
   const int kNumArguments = 3;
   const Array& kNoArgumentNames = Array::Handle();
   const Function& function = Function::Handle(
       Resolver::ResolveStatic(Library::Handle(Library::CoreLibrary()),
                               class_name,
@@ skipping 13 matching lines @@
     // TODO(turnidge): Instead of exiting here, just return the
     // exception so that the embedder can choose how to handle this
     // case.
     ProcessUnhandledException(uhe);
   }
   ASSERT(result.IsNull());
 }
 
 
 DART_EXPORT Dart_Handle Dart_RunLoop() {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
 
-  Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   Dart_Handle result;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     isolate->StandardRunLoop();
     result = Api::Success();
   } else {
     SetupErrorResult(&result);
   }
   isolate->set_long_jump_base(base);
   return result;
 }
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
-static void CompileSource(const Library& lib,
+static void CompileSource(Isolate* isolate,
+                          const Library& lib,
                           const String& url,
                           const String& source,
                           RawScript::Kind kind,
                           Dart_Handle* result) {
   const Script& script = Script::Handle(Script::New(url, source, kind));
-  Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     Compiler::Compile(lib, script);
     *result = Api::NewLocalHandle(lib);
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadScript(Dart_Handle url,
                                         Dart_Handle source,
                                         Dart_LibraryTagHandler handler) {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  DARTSCOPE(isolate);
   TIMERSCOPE(time_script_loading);
   const String& url_str = String::CheckedHandle(Api::UnwrapHandle(url));
   const String& source_str = String::CheckedHandle(Api::UnwrapHandle(source));
   Library& library = Library::Handle(isolate->object_store()->root_library());
   if (!library.IsNull()) {
     return Api::Error("Script already loaded");
   }
   isolate->set_library_tag_handler(handler);
   library = Library::New(url_str);
   library.Register();
   isolate->object_store()->set_root_library(library);
   Dart_Handle result;
-  CompileSource(library, url_str, source_str, RawScript::kScript, &result);
+  CompileSource(isolate,
+                library,
+                url_str,
+                source_str,
+                RawScript::kScript,
+                &result);
   return result;
 }
 
 
 DEFINE_FLAG(bool, compile_all, false, "Eagerly compile all code.");
 
-static void CompileAll(Dart_Handle* result) {
+static void CompileAll(Isolate* isolate, Dart_Handle* result) {
   *result = Api::Success();
   if (FLAG_compile_all) {
-    Isolate* isolate = Isolate::Current();
     ASSERT(isolate != NULL);
     LongJump* base = isolate->long_jump_base();
     LongJump jump;
     isolate->set_long_jump_base(&jump);
     if (setjmp(*jump.Set()) == 0) {
       Library::CompileAll();
     } else {
       SetupErrorResult(result);
     }
     isolate->set_long_jump_base(base);
   }
 }
 
 
 // Return error if isolate is in an inconsistent state.
 // Return NULL when no error condition exists.
-static const char* CheckIsolateState() {
+static const char* CheckIsolateState(Isolate* isolate) {
   if (!ClassFinalizer::FinalizePendingClasses()) {
     // Make a copy of the error message as the original message string
     // may get deallocated when we return back from the Dart API call.
     const String& err =
-    String::Handle(Isolate::Current()->object_store()->sticky_error());
+    String::Handle(isolate->object_store()->sticky_error());
     const char* errmsg = err.ToCString();
     intptr_t errlen = strlen(errmsg) + 1;
     char* msg = reinterpret_cast<char*>(Api::Allocate(errlen));
     OS::SNPrint(msg, errlen, "%s", errmsg);
     return msg;
   }
   return NULL;
 }
 
 
 DART_EXPORT Dart_Handle Dart_CompileAll() {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   Dart_Handle result;
-  const char* msg = CheckIsolateState();
+  const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::Error(msg);
   }
-  CompileAll(&result);
+  CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsLibrary();
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryUrl(Dart_Handle library) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);

[Ivan Posva, 2011/11/11 22:07:07]

How about changing this to:
DARTSCOPE(Isolate::Current());

It is such a repeating pattern.

[siva, 2011/11/12 03:01:05]

Done.

   const Library& lib = Library::CheckedHandle(Api::UnwrapHandle(library));
   if (lib.IsNull()) {
     return Api::Error("Null library");
   }
   const String& url = String::Handle(lib.url());
   ASSERT(!url.IsNull());
   return Api::NewLocalHandle(url);
 }
 
 
 DART_EXPORT Dart_Handle Dart_LibraryImportLibrary(Dart_Handle library_in,
                                                   Dart_Handle import_in) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Library& library =
       Library::CheckedHandle(Api::UnwrapHandle(library_in));
   if (library.IsNull()) {
     return Api::Error("Null library");
   }
   const Library& import =
       Library::CheckedHandle(Api::UnwrapHandle(import_in));
   library.AddImport(import);
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_LookupLibrary(Dart_Handle url) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   String& url_str = String::Handle();
   UNWRAP_NONNULL(url, url_str, String);
   const Library& library = Library::Handle(Library::LookupLibrary(url_str));
   if (library.IsNull()) {
     return Api::Error("%s: library '%s' not found.",
                       CURRENT_FUNC, url_str.ToCString());
   } else {
     return Api::NewLocalHandle(library);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadLibrary(Dart_Handle url, Dart_Handle source) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const String& url_str = String::CheckedHandle(Api::UnwrapHandle(url));
   const String& source_str = String::CheckedHandle(Api::UnwrapHandle(source));
   Library& library = Library::Handle(Library::LookupLibrary(url_str));
   if (library.IsNull()) {
     library = Library::New(url_str);
     library.Register();
   }
   Dart_Handle result;
-  CompileSource(library, url_str, source_str, RawScript::kLibrary, &result);
+  CompileSource(isolate,
+                library,
+                url_str,
+                source_str,
+                RawScript::kLibrary,
+                &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadSource(Dart_Handle library_in,
                                         Dart_Handle url_in,
                                         Dart_Handle source_in) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const String& url = String::CheckedHandle(Api::UnwrapHandle(url_in));
   const String& source = String::CheckedHandle(Api::UnwrapHandle(source_in));
   const Library& library =
       Library::CheckedHandle(Api::UnwrapHandle(library_in));
   Dart_Handle result;
-  CompileSource(library, url, source, RawScript::kSource, &result);
+  CompileSource(isolate, library, url, source, RawScript::kSource, &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetNativeResolver(
     Dart_Handle library,
     Dart_NativeEntryResolver resolver) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Library& lib = Library::CheckedHandle(Api::UnwrapHandle(library));
   if (lib.IsNull()) {
     return Api::Error("Invalid parameter, Unknown library specified");
   }
   lib.set_native_entry_resolver(resolver);
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   Object& result = Object::Handle();
   if (obj.IsString()) {
     result = obj.raw();
   } else if (obj.IsInstance()) {
     Instance& receiver = Instance::Handle();
     receiver ^= obj.raw();
     result = DartLibraryCalls::ToString(receiver);
     if (result.IsUnhandledException()) {
       return Api::Error("An exception occurred when converting to string");
     }
   } else {
     // This is a VM internal object. Call the C++ method of printing.
     result = String::New(obj.ToCString());
   }
   return Api::NewLocalHandle(result);
 }
 
 
 DART_EXPORT Dart_Handle Dart_Null() {
   return Api::Null();
 }
 
 
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsNull();
 }
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsClosure();
 }
 
 
 DART_EXPORT int64_t Dart_ClosureSmrck(Dart_Handle object) {
-  Zone zone;
-  HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Closure& obj = Closure::CheckedHandle(Api::UnwrapHandle(object));
   const Integer& smrck = Integer::Handle(obj.smrck());
   return smrck.IsNull() ? 0 : smrck.AsInt64Value();
 }
 
 
 DART_EXPORT void Dart_ClosureSetSmrck(Dart_Handle object, int64_t value) {
-  Zone zone;
-  HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Closure& obj = Closure::CheckedHandle(Api::UnwrapHandle(object));
   const Integer& smrck = Integer::Handle(Integer::New(value));
   obj.set_smrck(smrck);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Instance& expected = Instance::CheckedHandle(Api::UnwrapHandle(obj1));
   const Instance& actual = Instance::CheckedHandle(Api::UnwrapHandle(obj2));
   const Instance& result =
       Instance::Handle(DartLibraryCalls::Equals(expected, actual));
   if (result.IsBool()) {
     Bool& b = Bool::Handle();
     b ^= result.raw();
     *value = b.value();
     return Api::Success();
   } else {
     return Api::Error("An exception occured when calling '=='");
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_IsSame(Dart_Handle obj1, Dart_Handle obj2,
                                     bool* value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& expected = Object::Handle(Api::UnwrapHandle(obj1));
   const Object& actual = Object::Handle(Api::UnwrapHandle(obj2));
   *value = (expected.raw() == actual.raw());
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetClass(Dart_Handle library, Dart_Handle name) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString()) {
     return Api::Error("Invalid class name specified");
   }
   const Library& lib = Library::CheckedHandle(Api::UnwrapHandle(library));
   if (lib.IsNull()) {
     return Api::Error("Invalid parameter, Unknown library specified");
   }
   String& cls_name = String::Handle();
   cls_name ^= param.raw();
   const Class& cls = Class::Handle(lib.LookupClass(cls_name));
   if (cls.IsNull()) {
     const String& lib_name = String::Handle(lib.name());
     return Api::Error("Class '%s' not found in library '%s'.",
                       cls_name.ToCString(), lib_name.ToCString());
   }
   return Api::NewLocalHandle(cls);
 }
 
 
 // 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,
                                           Dart_Handle clazz,
                                           bool* value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Class& cls = Class::CheckedHandle(Api::UnwrapHandle(clazz));
   if (cls.IsNull()) {
     return Api::Error("instanceof check against null class");
   }
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   Instance& instance = Instance::Handle();
   instance ^= obj.raw();
   // Finalize all classes.
-  const char* msg = CheckIsolateState();
+  const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::Error(msg);
   }
   const Type& type = Type::Handle(Type::NewNonParameterizedType(cls));
   *value = instance.Is(type);
   return Api::Success();
 }
 
 
 // TODO(iposva): The argument should be an instance.
 DART_EXPORT bool Dart_IsNumber(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsNumber();
 }
 
 
 DART_EXPORT bool Dart_IsInteger(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsInteger();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Integer& obj = Integer::Handle(Integer::New(value));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const String& str_obj = String::Handle(String::New(str));
   const Integer& obj = Integer::Handle(Integer::New(str_obj));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerValue(Dart_Handle integer, int64_t* value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
   if (obj.IsSmi() || obj.IsMint()) {
     Integer& integer = Integer::Handle();
     integer ^= obj.raw();
     *value = integer.AsInt64Value();
     return Api::Success();
   }
   if (obj.IsBigint()) {
     Bigint& bigint = Bigint::Handle();
     bigint ^= obj.raw();
     if (BigintOperations::FitsIntoInt64(bigint)) {
       *value = BigintOperations::ToInt64(bigint);
       return Api::Success();
     } else {
       return Api::Error("Integer too big to fit in int64_t");
     }
   }
   return Api::Error("Object is not a Integer");
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerValueHexCString(Dart_Handle integer,
                                                     const char** value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
   Bigint& bigint = Bigint::Handle();
   if (obj.IsSmi() || obj.IsMint()) {
     Integer& integer = Integer::Handle();
     integer ^= obj.raw();
     bigint ^= BigintOperations::NewFromInt64(integer.AsInt64Value());
     *value = BigintOperations::ToHexCString(bigint, &Api::Allocate);
     return Api::Success();
   }
   if (obj.IsBigint()) {
     bigint ^= obj.raw();
     *value = BigintOperations::ToHexCString(bigint, &Api::Allocate);
     return Api::Success();
   }
   return Api::Error("Object is not a Integer");
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoInt64(Dart_Handle integer,
                                                   bool* fits) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
   if (obj.IsSmi() || obj.IsMint()) {
     *fits = true;
     return Api::Success();
   } else if (obj.IsBigint()) {
 #if defined(DEBUG)
     Bigint& bigint = Bigint::Handle();
     bigint ^= obj.raw();
     ASSERT(!BigintOperations::FitsIntoInt64(bigint));
 #endif
     *fits = false;
     return Api::Success();
   }
   return Api::Error("Object is not a Integer");
 }
 
 
 DART_EXPORT Dart_Handle Dart_True() {
   return Api::True();
 }
 
 
 DART_EXPORT Dart_Handle Dart_False() {
   return Api::False();
 }
 
 
 DART_EXPORT bool Dart_IsBoolean(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsBool();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewBoolean(bool value) {
   return value ? Api::True() : Api::False();
 }
 
 
 DART_EXPORT Dart_Handle Dart_BooleanValue(Dart_Handle bool_object,
                                           bool* value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(bool_object));
   if (obj.IsBool()) {
     Bool& bool_obj = Bool::Handle();
     bool_obj ^= obj.raw();
     *value = bool_obj.value();
     return Api::Success();
   }
   return Api::Error("Object is not a Boolean");
 }
 
 
 DART_EXPORT bool Dart_IsDouble(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsDouble();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Double& obj = Double::Handle(Double::New(value));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle integer, double* result) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(integer));
   if (obj.IsDouble()) {
     Double& double_obj = Double::Handle();
     double_obj ^= obj.raw();
     *result = double_obj.value();
     return Api::Success();
   }
   return Api::Error("Object is not a Double");
 }
 
 
 DART_EXPORT bool Dart_IsString(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsString();
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringLength(Dart_Handle str, intptr_t* len) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(str));
   if (obj.IsString()) {
     String& string_obj = String::Handle();
     string_obj ^= obj.raw();
     *len = string_obj.Length();
     return Api::Success();
   }
   return Api::Error("Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString(const char* str) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const String& obj = String::Handle(String::New(str));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString8(const uint8_t* codepoints,
                                         intptr_t length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const String& obj = String::Handle(String::New(codepoints, length));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString16(const uint16_t* codepoints,
                                          intptr_t length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const String& obj = String::Handle(String::New(codepoints, length));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewString32(const uint32_t* codepoints,
                                          intptr_t length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const String& obj = String::Handle(String::New(codepoints, length));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT bool Dart_IsString8(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsOneByteString();
 }
 
 
 DART_EXPORT bool Dart_IsString16(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   return obj.IsOneByteString() || obj.IsTwoByteString();
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringGet8(Dart_Handle str,
                                         uint8_t* codepoints,
                                         intptr_t* length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(str));
   if (obj.IsOneByteString()) {
     OneByteString& string_obj = OneByteString::Handle();
     string_obj ^= obj.raw();
     intptr_t str_len = string_obj.Length();
     intptr_t copy_len = (str_len > *length) ? *length : str_len;
     for (intptr_t i = 0; i < copy_len; i++) {
       codepoints[i] = static_cast<uint8_t>(string_obj.CharAt(i));
     }
     *length= copy_len;
     return Api::Success();
   }
   return Api::Error(obj.IsString()
                     ? "Object is not a String8"
                     : "Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringGet16(Dart_Handle str,
                                          uint16_t* codepoints,
                                          intptr_t* length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(str));
   if (obj.IsOneByteString() || obj.IsTwoByteString()) {
     String& string_obj = String::Handle();
     string_obj ^= obj.raw();
     intptr_t str_len = string_obj.Length();
     intptr_t copy_len = (str_len > *length) ? *length : str_len;
     for (intptr_t i = 0; i < copy_len; i++) {
       codepoints[i] = static_cast<uint16_t>(string_obj.CharAt(i));
     }
     *length = copy_len;
     return Api::Success();
   }
   return Api::Error(obj.IsString()
                     ? "Object is not a String16"
                     : "Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringGet32(Dart_Handle str,
                                          uint32_t* codepoints,
                                          intptr_t* length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(str));
   if (obj.IsString()) {
     String& string_obj = String::Handle();
     string_obj ^= obj.raw();
     intptr_t str_len = string_obj.Length();
     intptr_t copy_len = (str_len > *length) ? *length : str_len;
     for (intptr_t i = 0; i < copy_len; i++) {
       codepoints[i] = static_cast<uint32_t>(string_obj.CharAt(i));
     }
     *length = copy_len;
     return Api::Success();
   }
   return Api::Error("Object is not a String");
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle object,
                                              const char** result) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   if (obj.IsString()) {
     const char* string_value = obj.ToCString();
     intptr_t string_length = strlen(string_value);
     char* res = reinterpret_cast<char*>(Api::Allocate(string_length + 1));
     if (res == NULL) {
       return Api::Error("Unable to allocate memory");
     }
     strncpy(res, string_value, string_length + 1);
     ASSERT(res[string_length] == '\0');
     *result = res;
     return Api::Success();
   }
   return Api::Error("Object is not a String");
 }
 
 
 static RawInstance* GetListInstance(Isolate* isolate, const Object& obj) {
   if (obj.IsInstance()) {
     Instance& instance = Instance::Handle();
     instance ^= obj.raw();
     const Type& type = Type::Handle(isolate->object_store()->list_interface());
     return instance.Is(type) ? instance.raw() : Instance::null();
   }
   return Instance::null();
 }
 
 
 DART_EXPORT bool Dart_IsList(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   return (obj.IsArray() ||
-          (GetListInstance(Isolate::Current(), obj) != Instance::null()));
+          (GetListInstance(isolate, obj) != Instance::null()));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewList(intptr_t length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Array& obj = Array::Handle(Array::New(length));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t* len) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     *len = array_obj.Length();
     return Api::Success();
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
-  Isolate* isolate = Isolate::Current();
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("length"));
     name = Field::GetterName(name);
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 1, 0));
     if (!function.IsNull()) {
       GrowableArray<const Object*> args(0);
       LongJump* base = isolate->long_jump_base();
       LongJump jump;
@@ skipping 64 matching lines @@
   SetupErrorResult(result);
   isolate->set_long_jump_base(base);
   return Object::null();
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     if ((offset + length) <= array_obj.Length()) {
       Object& element = Object::Handle();
       Integer& integer  = Integer::Handle();
       for (int i = 0; i < length; i++) {
         element = array_obj.At(offset + i);
         integer ^= element.raw();
         native_array[i] = static_cast<uint8_t>(integer.AsInt64Value() & 0xff);
         ASSERT(integer.AsInt64Value() <= 0xff);
         // TODO(hpayer): value should always be smaller then 0xff. Add error
         // handling.
       }
       return Api::Success();
     }
     return Api::Error("Invalid length passed in to access array elements");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
-  Isolate* isolate = Isolate::Current();
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]"));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 2, 0));
     if (!function.IsNull()) {
       Object& element = Object::Handle();
       Integer& intobj = Integer::Handle();
       Dart_Handle result;
       for (int i = 0; i < length; i++) {
         intobj = Integer::New(offset + i);
         element = GetListAt(isolate, instance, intobj, function, &result);
         if (!Dart_IsValid(result)) {
           return result;  // Error condition.
         }
         intobj ^= element.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);
       }
       return Api::Success();
     }
   }
   return Api::Error("Object does not implement the 'List' interface");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListGetAt(Dart_Handle list, intptr_t index) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     if ((index >= 0) && (index < array_obj.Length())) {
       const Object& element = Object::Handle(array_obj.At(index));
       return Api::NewLocalHandle(element);
     }
     return Api::Error("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.
-  Isolate* isolate = Isolate::Current();
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]"));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 2, 0));
     if (!function.IsNull()) {
       Object& element = Object::Handle();
       Integer& indexobj = Integer::Handle();
       Dart_Handle result;
       indexobj = Integer::New(index);
@@ skipping 38 matching lines @@
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAsBytes(Dart_Handle list,
                                             intptr_t offset,
                                             uint8_t* native_array,
                                             intptr_t length) {
-  Zone zone;
-  HandleScope scope;
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     Integer& integer = Integer::Handle();
     if ((offset + length) <= array_obj.Length()) {
       for (int i = 0; i < length; i++) {
         integer ^= Integer::New(native_array[i]);
         array_obj.SetAt(offset + i, integer);
       }
       return Api::Success();
     }
     return Api::Error("Invalid length passed in to set array elements");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
-  Isolate* isolate = Isolate::Current();
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]="));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 3, 0));
     if (!function.IsNull()) {
       Integer& indexobj = Integer::Handle();
       Integer& valueobj = Integer::Handle();
       Dart_Handle result;
       for (int i = 0; i < length; i++) {
         indexobj = Integer::New(offset + i);
         valueobj ^= Integer::New(native_array[i]);
         SetListAt(isolate, instance, indexobj, valueobj, function, &result);
         if (!Dart_IsValid(result)) {
           return result;  // Error condition.
         }
       }
       return Api::Success();
     }
   }
   return Api::Error("Object does not implement the 'List' interface");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ListSetAt(Dart_Handle list,
                                        intptr_t index,
                                        Dart_Handle value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     Array& array_obj = Array::Handle();
     array_obj ^= obj.raw();
     const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
     if ((index >= 0) && (index < array_obj.Length())) {
       array_obj.SetAt(index, value_obj);
       return Api::Success();
     }
     return Api::Error("Invalid index passed in to set array element");
   }
   // TODO(5526318): Make access to GrowableObjectArray more efficient.
   // Now check and handle a dart object that implements the List interface.
-  Isolate* isolate = Isolate::Current();
   const Instance& instance = Instance::Handle(GetListInstance(isolate, obj));
   if (!instance.IsNull()) {
     String& name = String::Handle(String::New("[]="));
     const Function& function = Function::Handle(
         Resolver::ResolveDynamic(instance, name, 3, 0));
     if (!function.IsNull()) {
       Dart_Handle result;
       const Integer& index_obj = Integer::Handle(Integer::New(index));
       const Object& value_obj = Object::Handle(Api::UnwrapHandle(value));
       SetListAt(isolate, instance, index_obj, value_obj, function, &result);
       return result;
     }
   }
   return Api::Error("Object does not implement the 'List' interface");
 }
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
-static void InvokeStatic(const Function& function,
+static void InvokeStatic(Isolate* isolate,
+                         const Function& function,
                          GrowableArray<const Object*>& args,
                          Dart_Handle* result) {
-  Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Array& kNoArgumentNames = Array::Handle();
     const Instance& retval = Instance::Handle(
         DartEntry::InvokeStatic(function, args, kNoArgumentNames));
     *result = Api::NewLocalHandle(retval);
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
-static void InvokeDynamic(const Instance& receiver,
+static void InvokeDynamic(Isolate* isolate,
+                          const Instance& receiver,
                           const Function& function,
                           GrowableArray<const Object*>& args,
                           Dart_Handle* result) {
-  Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Array& kNoArgumentNames = Array::Handle();
     const Instance& retval = Instance::Handle(
         DartEntry::InvokeDynamic(receiver, function, args, kNoArgumentNames));
     *result = Api::NewLocalHandle(retval);
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 // NOTE: Need to pass 'result' as a parameter here in order to avoid
 // warning: variable 'result' might be clobbered by 'longjmp' or 'vfork'
 // which shows up because of the use of setjmp.
-static void InvokeClosure(const Closure& closure,
+static void InvokeClosure(Isolate* isolate,
+                          const Closure& closure,
                           GrowableArray<const Object*>& args,
                           Dart_Handle* result) {
-  Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     const Array& kNoArgumentNames = Array::Handle();
     const Instance& retval = Instance::Handle(
         DartEntry::InvokeClosure(closure, args, kNoArgumentNames));
     *result = Api::NewLocalHandle(retval);
   } else {
     SetupErrorResult(result);
   }
   isolate->set_long_jump_base(base);
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeStatic(Dart_Handle library_in,
                                           Dart_Handle class_name_in,
                                           Dart_Handle function_name_in,
                                           int number_of_arguments,
                                           Dart_Handle* arguments) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   // Finalize all classes.
-  const char* msg = CheckIsolateState();
+  const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::Error(msg);
   }
 
   // Now try to resolve and invoke the static function.
   const Library& library =
       Library::CheckedHandle(Api::UnwrapHandle(library_in));
   if (library.IsNull()) {
     return Api::Error("No library specified");
   }
@@ skipping 26 matching lines @@
                   class_name.ToCString(), function_name.ToCString());
     }
     return Api::Error(msg);
   }
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
-  InvokeStatic(function, dart_arguments, &retval);
+  InvokeStatic(isolate, function, dart_arguments, &retval);
   return retval;
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeDynamic(Dart_Handle object,
                                            Dart_Handle function_name,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(object));
   // Let the resolver figure out the correct target for null receiver.
   // E.g., (null).toString() should execute correctly.
   if (!obj.IsNull() && !obj.IsInstance()) {
     return Api::Error(
         "Invalid receiver (not instance) passed to invoke dynamic");
   }
   if (function_name == NULL) {
     return Api::Error("Invalid function name specified");
   }
@@ skipping 12 matching lines @@
     // TODO(5415268): Invoke noSuchMethod instead of failing.
     OS::PrintErr("Unable to find instance function: %s\n", name.ToCString());
     return Api::Error("Unable to find instance function");
   }
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
-  InvokeDynamic(receiver, function, dart_arguments, &retval);
+  InvokeDynamic(isolate, receiver, function, dart_arguments, &retval);
   return retval;
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& obj = Object::Handle(Api::UnwrapHandle(closure));
   if (obj.IsNull()) {
     return Api::Error("Null object passed in to invoke closure");
   }
   if (!obj.IsClosure()) {
     return Api::Error("Invalid closure passed to invoke closure");
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
 
   // Now try to invoke the closure.
   Closure& closure_obj = Closure::Handle();
   closure_obj ^= obj.raw();
   Dart_Handle retval;
   GrowableArray<const Object*> dart_arguments(number_of_arguments);
   for (int i = 0; i < number_of_arguments; i++) {
     const Object& arg = Object::Handle(Api::UnwrapHandle(arguments[i]));
     dart_arguments.Add(&arg);
   }
-  InvokeClosure(closure_obj, dart_arguments, &retval);
+  InvokeClosure(isolate, closure_obj, dart_arguments, &retval);
   return retval;
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeArgument(Dart_NativeArguments args,
                                                int index) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   const Object& obj = Object::Handle(arguments->At(index));
   return Api::NewLocalHandle(obj);
 }
 
 
 DART_EXPORT int Dart_GetNativeArgumentCount(Dart_NativeArguments args) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   return arguments->Count();
 }
 
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(Object::Handle(Api::UnwrapHandle(retval)));
 }
 
 
 DART_EXPORT bool Dart_ExceptionOccurred(Dart_Handle result) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& retval  = Object::Handle(Api::UnwrapHandle(result));
   return retval.IsUnhandledException();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetException(Dart_Handle result) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& retval = Object::Handle(Api::UnwrapHandle(result));
   if (retval.IsUnhandledException()) {
     const UnhandledException& unhandled = UnhandledException::Handle(
         reinterpret_cast<RawUnhandledException*>(retval.raw()));
     const Object& exception = Object::Handle(unhandled.exception());
     return Api::NewLocalHandle(exception);
   }
   return Api::Error("Object is not an unhandled exception object");
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetStacktrace(Dart_Handle unhandled_excp) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& retval = Object::Handle(Api::UnwrapHandle(unhandled_excp));
   if (retval.IsUnhandledException()) {
     const UnhandledException& unhandled = UnhandledException::Handle(
         reinterpret_cast<RawUnhandledException*>(retval.raw()));
     const Object& stacktrace = Object::Handle(unhandled.stacktrace());
     return Api::NewLocalHandle(stacktrace);
   }
   return Api::Error("Object is not an unhandled exception object");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  DARTSCOPE(isolate);
   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::Error("No Dart frames on stack, cannot throw exception");
   }
   const Instance& excp = Instance::CheckedHandle(Api::UnwrapHandle(exception));
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
   Exceptions::Throw(excp);
   return Api::Error("Exception was not thrown, internal error");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace) {
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   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::Error("No Dart frames on stack, cannot throw exception");
   }
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  DARTSCOPE(isolate);
   const Instance& excp = Instance::CheckedHandle(Api::UnwrapHandle(exception));
   const Instance& stk = Instance::CheckedHandle(Api::UnwrapHandle(stacktrace));
   // Unwind all the API scopes till the exit frame before throwing an
   // exception.
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   state->UnwindScopes(isolate->top_exit_frame_info());
   Exceptions::ReThrow(excp, stk);
   return Api::Error("Exception was not re thrown, internal error");
 }
@@ skipping 17 matching lines @@
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   state->set_top_scope(scope->previous());  // Reset top scope to previous.
   delete scope;  // Free up the old scope which we have just exited.
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewPersistentHandle(Dart_Handle object) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
   Isolate* isolate = Isolate::Current();
-  ASSERT(isolate != NULL);
+  DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Object& old_ref = Object::Handle(Api::UnwrapHandle(object));
   PersistentHandle* new_ref = state->persistent_handles().AllocateHandle();
   new_ref->set_raw(old_ref);
   return reinterpret_cast<Dart_Handle>(new_ref);
 }
 
 
 DART_EXPORT Dart_Handle Dart_MakeWeakPersistentHandle(Dart_Handle object) {
@@ skipping 100 matching lines @@
       return Api::NewLocalHandle(function);
     }
     cls = cls.SuperClass();
   }
   return Api::Error("Unable to find field in the class");
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetStaticField(Dart_Handle cls,
                                             Dart_Handle name) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   Dart_Handle result = LookupStaticField(cls, name, kGetter);
   if (!::Dart_IsValid(result)) {
     return result;
   }
   Object& retval = Object::Handle();
   const Object& obj = Object::Handle(Api::UnwrapHandle(result));
   if (obj.IsField()) {
     Field& fld = Field::Handle();
     fld ^= obj.raw();
     retval = fld.value();
     return Api::NewLocalHandle(retval);
   } else {
     Function& func = Function::Handle();
     func ^= obj.raw();
     GrowableArray<const Object*> args;
-    InvokeStatic(func, args, &result);
+    InvokeStatic(isolate, func, args, &result);
     if (::Dart_IsValid(result)) {
       if (Dart_ExceptionOccurred(result)) {
         return Api::Error(
             "An exception occurred when getting the static field");
       }
     }
     return result;
   }
 }
 
 
 // TODO(iposva): The value parameter should be documented as being an instance.
 DART_EXPORT Dart_Handle Dart_SetStaticField(Dart_Handle cls,
                                             Dart_Handle name,
                                             Dart_Handle value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   Dart_Handle result = LookupStaticField(cls, name, kSetter);
   if (!::Dart_IsValid(result)) {
     return result;
   }
   Field& fld = Field::Handle();
   fld ^= Api::UnwrapHandle(result);
   if (fld.is_final()) {
     return Api::Error("Specified field is a static final field in the class");
   }
   const Object& val = Object::Handle(Api::UnwrapHandle(value));
   Instance& instance = Instance::Handle();
   instance ^= val.raw();
   fld.set_value(instance);
   return Api::NewLocalHandle(val);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetInstanceField(Dart_Handle obj,
                                               Dart_Handle name) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::Error("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kGetter);
   if (!::Dart_IsValid(result)) {
     return result;
   }
   Function& func = Function::Handle();
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments;
-  InvokeDynamic(object, func, arguments, &result);
+  InvokeDynamic(isolate, object, func, arguments, &result);
   if (::Dart_IsValid(result)) {
     if (Dart_ExceptionOccurred(result)) {
       return Api::Error(
           "An exception occurred when accessing the instance field");
     }
   }
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetInstanceField(Dart_Handle obj,
                                               Dart_Handle name,
                                               Dart_Handle value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::Error("Invalid object passed in to access instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   Dart_Handle result = LookupInstanceField(object, name, kSetter);
   if (!::Dart_IsValid(result)) {
     return result;
   }
   Function& func = Function::Handle();
   func ^= Api::UnwrapHandle(result);
   GrowableArray<const Object*> arguments(1);
   const Object& arg = Object::Handle(Api::UnwrapHandle(value));
   arguments.Add(&arg);
-  InvokeDynamic(object, func, arguments, &result);
+  InvokeDynamic(isolate, object, func, arguments, &result);
   if (::Dart_IsValid(result)) {
     if (Dart_ExceptionOccurred(result)) {
       return Api::Error(
           "An exception occurred when setting the instance field");
     }
   }
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateNativeWrapperClass(Dart_Handle library,
                                                       Dart_Handle name,
                                                       int field_count) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(name));
   if (param.IsNull() || !param.IsString() || field_count <= 0) {
     return Api::Error(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   String& cls_name = String::Handle();
   cls_name ^= param.raw();
   cls_name = String::NewSymbol(cls_name);
   Library& lib = Library::Handle();
   lib ^= Api::UnwrapHandle(library);
   if (lib.IsNull()) {
     return Api::Error(
         "Invalid arguments passed to Dart_CreateNativeWrapperClass");
   }
   const Class& cls = Class::Handle(Class::NewNativeWrapper(&lib,
                                                            cls_name,
                                                            field_count));
   if (cls.IsNull()) {
     return Api::Error(
         "Unable to create native wrapper class : already exists");
   }
   return Api::NewLocalHandle(cls);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t* value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::Error(
         "Invalid object passed in to access native instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   if (!object.IsValidNativeIndex(index)) {
     return Api::Error(
         "Invalid index passed in to access native instance field");
   }
   *value = object.GetNativeField(index);
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetNativeInstanceField(Dart_Handle obj,
                                                     int index,
                                                     intptr_t value) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& param = Object::Handle(Api::UnwrapHandle(obj));
   if (param.IsNull() || !param.IsInstance()) {
     return Api::Error("Invalid object passed in to set native instance field");
   }
   Instance& object = Instance::Handle();
   object ^= param.raw();
   if (!object.IsValidNativeIndex(index)) {
     return Api::Error("Invalid index passed in to set native instance field");
   }
   object.SetNativeField(index, value);
   return Api::Success();
 }
 
 
 static uint8_t* ApiAllocator(uint8_t* ptr,
                              intptr_t old_size,
                              intptr_t new_size) {
   uword new_ptr = Api::Reallocate(reinterpret_cast<uword>(ptr),
                                   old_size,
                                   new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 DART_EXPORT Dart_Handle Dart_CreateSnapshot(uint8_t** snapshot_buffer,
                                             intptr_t* snapshot_size) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   if (snapshot_buffer == NULL || snapshot_size == NULL) {
     return Api::Error("Invalid input parameters to Dart_CreateSnapshot");
   }
-  const char* msg = CheckIsolateState();
+  const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::Error(msg);
   }
   // Since this is only a snapshot the root library should not be set.
-  Isolate* isolate = Isolate::Current();
   isolate->object_store()->set_root_library(Library::Handle());
   SnapshotWriter writer(true, snapshot_buffer, ApiAllocator);
   writer.WriteFullSnapshot();
   *snapshot_size = writer.Size();
   return Api::Success();
 }
 
 
 static uint8_t* allocator(uint8_t* ptr, intptr_t old_size, intptr_t new_size) {
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 DART_EXPORT bool Dart_PostIntArray(Dart_Port port,
                                    intptr_t len,
                                    intptr_t* data) {
   uint8_t* buffer = NULL;
   MessageWriter writer(&buffer, &allocator);
 
   writer.WriteMessage(len, data);
 
   // Post the message at the given port.
   return PortMap::PostMessage(port, kNoReplyPort, buffer);
 }
 
 
 DART_EXPORT bool Dart_Post(Dart_Port port, Dart_Handle handle) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(isolate);
   const Object& object = Object::Handle(Api::UnwrapHandle(handle));
   uint8_t* data = NULL;
   SnapshotWriter writer(false, &data, &allocator);
   writer.WriteObject(object.raw());
   writer.FinalizeBuffer();
   return PortMap::PostMessage(port, kNoReplyPort, data);
 }
 
 
 DART_EXPORT void Dart_InitPprofSupport() {
@@ skipping 80 matching lines @@
   Isolate* isolate = Isolate::Current();
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* true_handle = state->True();
   return reinterpret_cast<Dart_Handle>(true_handle);
 }
 
 
 Dart_Handle Api::Error(const char* format, ...) {
-  Zone zone;  // Setup a VM zone as we are creating some handles.
-  HandleScope scope;  // Setup a VM handle scope.
+  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);
@@ skipping 51 matching lines @@
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   ASSERT(scope != NULL);
   return scope->zone().Reallocate(ptr, old_size, new_size);
 }
 
 
 }  // namespace dart