First set of changes towards cleaning up the bytearray access APIs

vm/dart_api_impl.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 
 #include "vm/bigint_operations.h"
 #include "vm/class_finalizer.h"
 #include "vm/compiler.h"
 #include "vm/dart.h"
@@ skipping 174 matching lines @@
   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::NewError(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = isolate->current_zone()->Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(isolate, String::New(buffer));
   return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
+void Api::SetupCallbackError(Isolate* isolate) {
+  ASSERT(isolate != NULL);
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  state->SetupCallbackError();
+}
+
+
+Dart_Handle Api::CallbackError(Isolate* isolate) {
+  ASSERT(isolate != NULL);
+  ApiState* state = isolate->api_state();
+  ASSERT(state != NULL);
+  PersistentHandle* callback_error_handle = state->CallbackError();
+  return reinterpret_cast<Dart_Handle>(callback_error_handle);
+}
+
+
 Dart_Handle Api::Null(Isolate* isolate) {
   ASSERT(isolate != NULL);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   PersistentHandle* null_handle = state->Null();
   return reinterpret_cast<Dart_Handle>(null_handle);
 }
 
 
 Dart_Handle Api::True(Isolate* isolate) {
@@ skipping 166 matching lines @@
     return Api::NewError("Can only get stacktraces from error handles.");
   }
 }
 
 
 // Deprecated.
 // TODO(turnidge): Remove all uses and delete.
 DART_EXPORT Dart_Handle Dart_Error(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = isolate->current_zone()->Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(isolate, String::New(buffer));
   return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
 // TODO(turnidge): This clones Api::NewError.  I need to use va_copy to
 // fix this but not sure if it available on all of our builds.
 DART_EXPORT Dart_Handle Dart_NewApiError(const char* format, ...) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
 
   va_list args;
   va_start(args, format);
   intptr_t len = OS::VSNPrint(NULL, 0, format, args);
   va_end(args);
 
   char* buffer = isolate->current_zone()->Alloc<char>(len + 1);
   va_list args2;
   va_start(args2, format);
   OS::VSNPrint(buffer, (len + 1), format, args2);
   va_end(args2);
 
   const String& message = String::Handle(isolate, String::New(buffer));
   return Api::NewHandle(isolate, ApiError::New(message));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewUnhandledExceptionError(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
+
   const Instance& obj = Api::UnwrapInstanceHandle(isolate, exception);
   if (obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, exception, Instance);
   }
   const Instance& stacktrace = Instance::Handle(isolate);
   return Api::NewHandle(isolate, UnhandledException::New(obj, stacktrace));
 }
 
 
 DART_EXPORT Dart_Handle Dart_PropagateError(Dart_Handle handle) {
@@ skipping 43 matching lines @@
 }
 
 
 DART_EXPORT Dart_Handle Dart_ToString(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   if (obj.IsString()) {
     return Api::NewHandle(isolate, obj.raw());
   } else if (obj.IsInstance()) {
+    CHECK_CALLBACK_STATE(isolate);
     const Instance& receiver = Instance::Cast(obj);
     return Api::NewHandle(isolate, DartLibraryCalls::ToString(receiver));
   } else {
+    CHECK_CALLBACK_STATE(isolate);
     // This is a VM internal object. Call the C++ method of printing.
     return Api::NewHandle(isolate, String::New(obj.ToCString()));
   }
 }
 
 
 DART_EXPORT bool Dart_IdentityEquals(Dart_Handle obj1, Dart_Handle obj2) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   NoGCScope ngc;
   return Api::UnwrapHandle(obj1) == Api::UnwrapHandle(obj2);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewPersistentHandle(Dart_Handle object) {
   Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   const Object& old_ref = Object::Handle(isolate, Api::UnwrapHandle(object));
   PersistentHandle* new_ref = state->persistent_handles().AllocateHandle();
   new_ref->set_raw(old_ref);
   return reinterpret_cast<Dart_Handle>(new_ref);
 }
 
 static Dart_Handle AllocateFinalizableHandle(
     Isolate* isolate,
     FinalizablePersistentHandles* handles,
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   const Object& ref = Object::Handle(isolate, Api::UnwrapHandle(object));
   FinalizablePersistentHandle* finalizable_ref = handles->AllocateHandle();
   finalizable_ref->set_raw(ref);
   finalizable_ref->set_peer(peer);
   finalizable_ref->set_callback(callback);
   return reinterpret_cast<Dart_Handle>(finalizable_ref);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->weak_persistent_handles(),
                                    object,
                                    peer,
                                    callback);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewPrologueWeakPersistentHandle(
     Dart_Handle object,
     void* peer,
     Dart_WeakPersistentHandleFinalizer callback) {
   Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   ApiState* state = isolate->api_state();
   ASSERT(state != NULL);
   return AllocateFinalizableHandle(isolate,
                                    &state->prologue_weak_persistent_handles(),
                                    object,
                                    peer,
                                    callback);
 }
 
 
@@ skipping 221 matching lines @@
 DART_EXPORT Dart_Isolate Dart_CreateIsolate(const char* script_uri,
                                             const char* main,
                                             const uint8_t* snapshot,
                                             void* callback_data,
                                             char** error) {
   char* isolate_name = BuildIsolateName(script_uri, main);
   Isolate* isolate = Dart::CreateIsolate(isolate_name);
   free(isolate_name);
   {
     StackZone zone(isolate);
-    DARTSCOPE_NOCHECKS(isolate);
+    HANDLESCOPE(isolate);
     const Error& error_obj =
         Error::Handle(isolate,
                       Dart::InitializeIsolate(snapshot, callback_data));
     if (error_obj.IsNull()) {
       START_TIMER(time_total_runtime);
       return reinterpret_cast<Dart_Isolate>(isolate);
     }
     *error = strdup(error_obj.ToErrorCString());
   }
   Dart::ShutdownIsolate();
@@ skipping 133 matching lines @@
   MonitorLocker ml(data->monitor);
   data->done = true;
   ml.Notify();
 }
 
 
 DART_EXPORT Dart_Handle Dart_RunLoop() {
   Isolate* isolate = Isolate::Current();
 
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   Monitor monitor;
   MonitorLocker ml(&monitor);
   {
     SwitchIsolateScope switch_scope(NULL);
 
     RunLoopData data;
     data.monitor = &monitor;
     data.done = false;
     isolate->message_handler()->Run(
         Dart::thread_pool(),
@@ skipping 62 matching lines @@
 
   // Post the message at the given port.
   return PortMap::PostMessage(new Message(
       port_id, Message::kIllegalPort, buffer, writer.BytesWritten(),
       Message::kNormalPriority));
 }
 
 
 DART_EXPORT bool Dart_Post(Dart_Port port_id, Dart_Handle handle) {
   Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   const Object& object = Object::Handle(isolate, Api::UnwrapHandle(handle));
   uint8_t* data = NULL;
   MessageWriter writer(&data, &allocator);
   writer.WriteMessage(object);
   intptr_t len = writer.BytesWritten();
   return PortMap::PostMessage(new Message(
       port_id, Message::kIllegalPort, data, len, Message::kNormalPriority));
 }
 
 
@@ skipping 25 matching lines @@
   Isolate::SetCurrent(NULL);
 
   // TODO(turnidge): Check that the port is native before trying to close.
   return PortMap::ClosePort(native_port_id);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewSendPort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, DartLibraryCalls::NewSendPort(port_id));
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetReceivePort(Dart_Port port_id) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
+
   Library& isolate_lib = Library::Handle(isolate, Library::IsolateLibrary());
   ASSERT(!isolate_lib.IsNull());
   const String& class_name = String::Handle(
       isolate, isolate_lib.PrivateName(Symbols::_ReceivePortImpl()));
   // TODO(asiva): Symbols should contain private keys.
   const String& function_name =
       String::Handle(isolate_lib.PrivateName(Symbols::_get_or_create()));
   const int kNumArguments = 1;
   const Function& function = Function::Handle(
       isolate,
@@ skipping 71 matching lines @@
 
 DART_EXPORT bool Dart_IsNull(Dart_Handle object) {
   return Api::ClassId(object) == kNullCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_ObjectEquals(Dart_Handle obj1, Dart_Handle obj2,
                                           bool* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   const Instance& expected =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj1));
   const Instance& actual =
       Instance::CheckedHandle(isolate, Api::UnwrapHandle(obj2));
   const Object& result =
       Object::Handle(isolate, DartLibraryCalls::Equals(expected, actual));
   if (result.IsBool()) {
     *value = Bool::Cast(result).value();
     return Api::Success(isolate);
   } else if (result.IsError()) {
@@ skipping 24 matching lines @@
     return Api::NewError(
         "%s expects argument 'object' to be an instance of Object.",
         CURRENT_FUNC);
   }
   // Finalize all classes.
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError("%s", msg);
   }
   if (obj.IsInstance()) {
+    CHECK_CALLBACK_STATE(isolate);
     const Type& type = Type::Handle(isolate,
                                     Type::NewNonParameterizedType(cls));
     Error& malformed_type_error = Error::Handle(isolate);
     *value = Instance::Cast(obj).IsInstanceOf(type,
                                               TypeArguments::Handle(isolate),
                                               &malformed_type_error);
     ASSERT(malformed_type_error.IsNull());  // Type was created from a class.
   } else {
     *value = false;
   }
@@ skipping 44 matching lines @@
                                                   bool* fits) {
   // Fast path for Smis and Mints.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   intptr_t class_id = Api::ClassId(integer);
   if (class_id == kSmiCid || class_id == kMintCid) {
     *fits = true;
     return Api::Success(isolate);
   }
   // Slow path for Mints and Bigints.
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!BigintOperations::FitsIntoMint(Bigint::Cast(int_obj)));
   *fits = false;
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerFitsIntoUint64(Dart_Handle integer,
                                                    bool* fits) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *fits = (Api::SmiValue(integer) >= 0);
     return Api::Success(isolate);
   }
   // Slow path for Mints and Bigints.
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *fits = !int_obj.IsNegative();
   } else {
     *fits = BigintOperations::FitsIntoUint64(Bigint::Cast(int_obj));
   }
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewInteger(int64_t value) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Smi::IsValid64(value)) {
     NOHANDLESCOPE(isolate);
     return Api::NewHandle(isolate, Smi::New(static_cast<intptr_t>(value)));
   }
   // Slow path for Mints and Bigints.
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, Integer::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewIntegerFromHexCString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   const String& str_obj = String::Handle(isolate, String::New(str));
   return Api::NewHandle(isolate, Integer::New(str_obj));
 }
 
 
 DART_EXPORT Dart_Handle Dart_IntegerToInt64(Dart_Handle integer,
                                             int64_t* value) {
   // Fast path for Smis.
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     *value = Api::SmiValue(integer);
     return Api::Success(isolate);
   }
   // Slow path for Mints and Bigints.
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint()) {
     *value = int_obj.AsInt64Value();
     return Api::Success(isolate);
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
@@ skipping 13 matching lines @@
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   if (Api::IsSmi(integer)) {
     intptr_t smi_value = Api::SmiValue(integer);
     if (smi_value >= 0) {
       *value = smi_value;
       return Api::Success(isolate);
     }
   }
   // Slow path for Mints and Bigints.
-  DARTSCOPE_NOCHECKS(isolate);
+  DARTSCOPE(isolate);
   const Integer& int_obj = Api::UnwrapIntegerHandle(isolate, integer);
   if (int_obj.IsNull()) {
     RETURN_TYPE_ERROR(isolate, integer, Integer);
   }
   ASSERT(!int_obj.IsSmi());
   if (int_obj.IsMint() && !int_obj.IsNegative()) {
     *value = int_obj.AsInt64Value();
     return Api::Success(isolate);
   } else {
     const Bigint& bigint = Bigint::Cast(int_obj);
@@ skipping 78 matching lines @@
 
 
 DART_EXPORT bool Dart_IsDouble(Dart_Handle object) {
   return Api::ClassId(object) == kDoubleCid;
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewDouble(double value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, Double::New(value));
 }
 
 
 DART_EXPORT Dart_Handle Dart_DoubleValue(Dart_Handle double_obj,
                                          double* value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Double& obj = Api::UnwrapDoubleHandle(isolate, double_obj);
   if (obj.IsNull()) {
@@ skipping 28 matching lines @@
   return Api::Success(isolate);
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewStringFromCString(const char* str) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (str == NULL) {
     RETURN_NULL_ERROR(str);
   }
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, String::New(str));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewStringFromUTF8(const uint8_t* utf8_array,
                                                intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (utf8_array == NULL && length != 0) {
     RETURN_NULL_ERROR(utf8_array);
   }
   CHECK_LENGTH(length, String::kMaxElements);
   if (!Utf8::IsValid(utf8_array, length)) {
     return Api::NewError("%s expects argument 'str' to be valid UTF-8.",
                          CURRENT_FUNC);
   }
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, String::FromUTF8(utf8_array, length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewStringFromUTF16(const uint16_t* utf16_array,
                                                 intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (utf16_array == NULL && length != 0) {
     RETURN_NULL_ERROR(utf16_array);
   }
   CHECK_LENGTH(length, String::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, String::FromUTF16(utf16_array, length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewStringFromUTF32(const int32_t* utf32_array,
                                                 intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (utf32_array == NULL && length != 0) {
     RETURN_NULL_ERROR(utf32_array);
   }
   CHECK_LENGTH(length, String::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, String::FromUTF32(utf32_array, length));
 }
 
 
 DART_EXPORT bool Dart_IsExternalString(Dart_Handle object) {
   return RawObject::IsExternalStringClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ExternalStringGetPeer(Dart_Handle object,
@@ skipping 22 matching lines @@
     const uint8_t* latin1_array,
     intptr_t length,
     void* peer,
     Dart_PeerFinalizer cback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (latin1_array == NULL && length != 0) {
     RETURN_NULL_ERROR(latin1_array);
   }
   CHECK_LENGTH(length, String::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate,
                         String::NewExternal(latin1_array, length, peer, cback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalUTF16String(const uint16_t* utf16_array,
                                                     intptr_t length,
                                                     void* peer,
                                                     Dart_PeerFinalizer cback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (utf16_array == NULL && length != 0) {
     RETURN_NULL_ERROR(utf16_array);
   }
   CHECK_LENGTH(length, String::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate,
                         String::NewExternal(utf16_array, length, peer, cback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_StringToCString(Dart_Handle object,
                                              const char** cstr) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (cstr == NULL) {
@@ skipping 188 matching lines @@
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(object));
   return GetListInstance(isolate, obj) != Instance::null();
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewList(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_LENGTH(length, Array::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, Array::New(length));
 }
 
 
 #define GET_LIST_LENGTH(isolate, type, obj, len)                               \
   type& array = type::Handle(isolate);                                         \
   array ^= obj.raw();                                                          \
   *len = array.Length();                                                       \
   return Api::Success(isolate);                                                \
 
 
 DART_EXPORT Dart_Handle Dart_ListLength(Dart_Handle list, intptr_t* len) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsError()) {
     // Pass through errors.
     return list;
   }
   if (obj.IsByteArray()) {
     GET_LIST_LENGTH(isolate, ByteArray, obj, len);
   }
   if (obj.IsArray()) {
     GET_LIST_LENGTH(isolate, Array, obj, len);
   }
   if (obj.IsGrowableObjectArray()) {
     GET_LIST_LENGTH(isolate, GrowableObjectArray, obj, len);
   }
+  CHECK_CALLBACK_STATE(isolate);
+
   // Now check and handle a dart object that implements the List interface.
   const Instance& instance =
       Instance::Handle(isolate, GetListInstance(isolate, obj));
   if (instance.IsNull()) {
     return Api::NewError("Object does not implement the List interface");
   }
   const String& name = String::Handle(Field::GetterName(Symbols::Length()));
   const Function& function =
       Function::Handle(isolate, Resolver::ResolveDynamic(instance, name, 1, 0));
   if (function.IsNull()) {
@@ skipping 47 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   if (obj.IsArray()) {
     GET_LIST_ELEMENT(isolate, Array, obj, index);
   } else if (obj.IsGrowableObjectArray()) {
     GET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index);
   } else if (obj.IsError()) {
     return list;
   } else {
+    CHECK_CALLBACK_STATE(isolate);
+
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance, Symbols::IndexToken(), 2, 0));
       if (!function.IsNull()) {
         const int kNumArgs = 2;
         const Array& args = Array::Handle(isolate, Array::New(kNumArgs));
@@ skipping 30 matching lines @@
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(list));
   // If the list is immutable we call into Dart for the indexed setter to
   // get the unsupported operation exception as the result.
   if (obj.IsArray() && !obj.IsImmutableArray()) {
     SET_LIST_ELEMENT(isolate, Array, obj, index, value);
   } else if (obj.IsGrowableObjectArray()) {
     SET_LIST_ELEMENT(isolate, GrowableObjectArray, obj, index, value);
   } else if (obj.IsError()) {
     return list;
   } else {
+    CHECK_CALLBACK_STATE(isolate);
+
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance,
                                    Symbols::AssignIndexToken(),
                                    3,
                                    0));
@@ skipping 66 matching lines @@
   } else if (obj.IsGrowableObjectArray()) {
     GET_LIST_ELEMENT_AS_BYTES(isolate,
                               GrowableObjectArray,
                               obj,
                               native_array,
                               offset,
                               length);
   } else if (obj.IsError()) {
     return list;
   } else {
+    CHECK_CALLBACK_STATE(isolate);
+
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance, Symbols::IndexToken(), 2, 0));
       if (!function.IsNull()) {
         Object& result = Object::Handle(isolate);
         Integer& intobj = Integer::Handle(isolate);
@@ skipping 67 matching lines @@
   } else if (obj.IsGrowableObjectArray()) {
     SET_LIST_ELEMENT_AS_BYTES(isolate,
                               GrowableObjectArray,
                               obj,
                               native_array,
                               offset,
                               length);
   } else if (obj.IsError()) {
     return list;
   } else {
+    CHECK_CALLBACK_STATE(isolate);
+
     // Check and handle a dart object that implements the List interface.
     const Instance& instance =
         Instance::Handle(isolate, GetListInstance(isolate, obj));
     if (!instance.IsNull()) {
       const Function& function = Function::Handle(
           isolate,
           Resolver::ResolveDynamic(instance,
                                    Symbols::AssignIndexToken(),
                                    3,
                                    0));
@@ skipping 32 matching lines @@
 
 DART_EXPORT bool Dart_IsByteArrayExternal(Dart_Handle object) {
   return RawObject::IsExternalByteArrayClassId(Api::ClassId(object));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewByteArray(intptr_t length) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   CHECK_LENGTH(length, Uint8Array::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(isolate, Uint8Array::New(length));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalByteArray(uint8_t* data,
                                                   intptr_t length,
                                                   void* peer,
                                                   Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
     RETURN_NULL_ERROR(data);
   }
   CHECK_LENGTH(length, ExternalUint8Array::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(
       isolate, ExternalUint8Array::New(data, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_NewExternalClampedByteArray(
     uint8_t* data,
     intptr_t length,
     void* peer,
     Dart_PeerFinalizer callback) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   if (data == NULL && length != 0) {
     RETURN_NULL_ERROR(data);
   }
   CHECK_LENGTH(length, ExternalUint8ClampedArray::kMaxElements);
+  CHECK_CALLBACK_STATE(isolate);
   return Api::NewHandle(
       isolate, ExternalUint8ClampedArray::New(data, length, peer, callback));
 }
 
 
 DART_EXPORT Dart_Handle Dart_ExternalByteArrayGetData(Dart_Handle object,
                                                       void** data) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const ExternalUint8Array& array =
@@ skipping 19 matching lines @@
     RETURN_TYPE_ERROR(isolate, object, ExternalUint8Array);
   }
   if (peer == NULL) {
     RETURN_NULL_ERROR(peer);
   }
   *peer = array.GetPeer();
   return Api::Success(isolate);
 }
 
 
-template<typename T>
-Dart_Handle ByteArrayGetAt(T* value, Dart_Handle array, intptr_t offset) {
+DART_EXPORT Dart_Handle Dart_ScalarListAcquireData(Dart_Handle array,
+                                                   Dart_Scalar_Type* type,
+                                                   void** data,
+                                                   intptr_t* len) {
   Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
-  const ByteArray& array_obj = Api::UnwrapByteArrayHandle(isolate, array);
-  if (array_obj.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, array, ByteArray);
+  DARTSCOPE(isolate);
+  if (!RawObject::IsByteArrayClassId(Api::ClassId(array))) {
+    RETURN_TYPE_ERROR(isolate, array, 'scalar list');
   }
-  intptr_t length = sizeof(T);
-  if (!Utils::RangeCheck(offset, length, array_obj.ByteLength())) {
-    return Api::NewError("Invalid index passed in to get byte array element");
+  if (type == NULL) {
+    RETURN_NULL_ERROR(type);
   }
-  uint8_t* dst = reinterpret_cast<uint8_t*>(value);
-  ByteArray::Copy(dst, array_obj, offset, length);
+  if (data == NULL) {
+    RETURN_NULL_ERROR(data);
+  }
+  if (len == NULL) {
+    RETURN_NULL_ERROR(len);
+  }
+  isolate->IncrementNoGCScopeDepth();
+  START_NO_CALLBACK_SCOPE(isolate);
+
+  UNIMPLEMENTED();
   return Api::Success(isolate);
 }
 
 
-template<typename T>
-Dart_Handle ByteArraySetAt(Dart_Handle array, intptr_t offset, T value) {
+DART_EXPORT Dart_Handle Dart_ScalarListReleaseData(Dart_Handle array) {
   Isolate* isolate = Isolate::Current();
-  CHECK_ISOLATE(isolate);
-  const ByteArray& array_obj = Api::UnwrapByteArrayHandle(isolate, array);
-  if (array_obj.IsNull()) {
-    RETURN_TYPE_ERROR(isolate, array, ByteArray);
+  DARTSCOPE(isolate);
+  if (!RawObject::IsByteArrayClassId(Api::ClassId(array))) {
+    RETURN_TYPE_ERROR(isolate, array, 'scalar list');
   }
-  intptr_t length = sizeof(T);
-  if (!Utils::RangeCheck(offset, length, array_obj.ByteLength())) {
-    return Api::NewError("Invalid index passed in to get byte array element");
-  }
-  const uint8_t* src = reinterpret_cast<uint8_t*>(&value);
-  ByteArray::Copy(array_obj, offset, src, length);
+
+  UNIMPLEMENTED();
+  isolate->DecrementNoGCScopeDepth();
+  END_NO_CALLBACK_SCOPE(isolate);
   return Api::Success(isolate);
 }
 
 
-DART_EXPORT Dart_Handle Dart_ByteArrayGetInt8At(Dart_Handle array,
-                                                intptr_t byte_offset,
-                                                int8_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetInt8At(Dart_Handle array,
-                                                intptr_t byte_offset,
-                                                int8_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetUint8At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 uint8_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetUint8At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 uint8_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetInt16At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 int16_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetInt16At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 int16_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetUint16At(Dart_Handle array,
-                                                  intptr_t byte_offset,
-                                                  uint16_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetUint16At(Dart_Handle array,
-                                                  intptr_t byte_offset,
-                                                  uint16_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetInt32At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 int32_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetInt32At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 int32_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetUint32At(Dart_Handle array,
-                                                  intptr_t byte_offset,
-                                                  uint32_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetUint32At(Dart_Handle array,
-                                                  intptr_t byte_offset,
-                                                  uint32_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetInt64At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 int64_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetInt64At(Dart_Handle array,
-                                                 intptr_t byte_offset,
-                                                 int64_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetUint64At(Dart_Handle array,
-                                                  intptr_t byte_offset,
-                                                  uint64_t* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetUint64At(Dart_Handle array,
-                                                  intptr_t byte_offset,
-                                                  uint64_t value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetFloat32At(Dart_Handle array,
-                                                   intptr_t byte_offset,
-                                                   float* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetFloat32At(Dart_Handle array,
-                                                   intptr_t byte_offset,
-                                                   float value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArrayGetFloat64At(Dart_Handle array,
-                                                   intptr_t byte_offset,
-                                                   double* value) {
-  return ByteArrayGetAt(value, array, byte_offset);
-}
-
-
-DART_EXPORT Dart_Handle Dart_ByteArraySetFloat64At(Dart_Handle array,
-                                                   intptr_t byte_offset,
-                                                   double value) {
-  return ByteArraySetAt(array, byte_offset, value);
-}
-
-
 // --- Closures ---
 
 
 DART_EXPORT bool Dart_IsClosure(Dart_Handle object) {
   // We can't use a fast class index check here because there are many
   // different signature classes for closures.
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Instance& closure_obj = Api::UnwrapInstanceHandle(isolate, object);
   return (!closure_obj.IsNull() && closure_obj.IsClosure());
@@ skipping 13 matching lines @@
   RawFunction* rf = Closure::function(closure_obj);
   return Api::NewHandle(isolate, rf);
 }
 
 
 DART_EXPORT Dart_Handle Dart_InvokeClosure(Dart_Handle closure,
                                            int number_of_arguments,
                                            Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   const Instance& closure_obj = Api::UnwrapInstanceHandle(isolate, closure);
   if (closure_obj.IsNull() || !closure_obj.IsCallable(NULL, NULL)) {
     RETURN_TYPE_ERROR(isolate, closure, Instance);
   }
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
   ASSERT(ClassFinalizer::AllClassesFinalized());
@@ skipping 828 matching lines @@
   return constructor.raw();
 }
 
 
 DART_EXPORT Dart_Handle Dart_New(Dart_Handle clazz,
                                  Dart_Handle constructor_name,
                                  int number_of_arguments,
                                  Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   Object& result = Object::Handle(isolate);
 
   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.
   Class& cls =
       Class::Handle(isolate, Api::UnwrapClassHandle(isolate, clazz).raw());
   if (cls.IsNull()) {
     RETURN_TYPE_ERROR(isolate, clazz, Class);
   }
+
   String& base_constructor_name = String::Handle();
   base_constructor_name = cls.Name();
 
   // And get the name of the constructor to invoke.
   String& dot_name = String::Handle(isolate);
   const Object& name_obj =
       Object::Handle(isolate, Api::UnwrapHandle(constructor_name));
   if (name_obj.IsNull()) {
     dot_name = Symbols::Dot().raw();
   } else if (name_obj.IsString()) {
@@ skipping 66 matching lines @@
   return Api::NewHandle(isolate, new_object.raw());
 }
 
 
 DART_EXPORT Dart_Handle Dart_Invoke(Dart_Handle target,
                                     Dart_Handle name,
                                     int number_of_arguments,
                                     Dart_Handle* arguments) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
 
   const String& function_name = Api::UnwrapStringHandle(isolate, name);
   if (function_name.IsNull()) {
     RETURN_TYPE_ERROR(isolate, name, String);
   }
   if (number_of_arguments < 0) {
     return Api::NewError(
         "%s expects argument 'number_of_arguments' to be non-negative.",
         CURRENT_FUNC);
   }
@@ skipping 123 matching lines @@
   // initialized until the first time the getter is invoked.
   const Instance& value = Instance::Handle(isolate, fld.value());
   ASSERT(value.raw() != Object::transition_sentinel().raw());
   return value.raw() == Object::sentinel().raw();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetField(Dart_Handle container, Dart_Handle name) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
 
   const String& field_name = Api::UnwrapStringHandle(isolate, name);
   if (field_name.IsNull()) {
     RETURN_TYPE_ERROR(isolate, name, String);
   }
 
   const Object& obj = Object::Handle(isolate, Api::UnwrapHandle(container));
 
   Field& field = Field::Handle(isolate);
   Function& getter = Function::Handle(isolate);
@@ skipping 94 matching lines @@
         CURRENT_FUNC);
   }
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetField(Dart_Handle container,
                                       Dart_Handle name,
                                       Dart_Handle value) {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
 
   const String& field_name = Api::UnwrapStringHandle(isolate, name);
   if (field_name.IsNull()) {
     RETURN_TYPE_ERROR(isolate, name, String);
   }
 
   // Since null is allowed for value, we don't use UnwrapInstanceHandle.
   const Object& value_obj = Object::Handle(isolate, Api::UnwrapHandle(value));
   if (!value_obj.IsNull() && !value_obj.IsInstance()) {
     RETURN_TYPE_ERROR(isolate, value, Instance);
@@ skipping 133 matching lines @@
     RETURN_TYPE_ERROR(isolate, name, String);
   }
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
   if (field_count <= 0) {
     return Api::NewError(
         "Negative field_count passed to Dart_CreateNativeWrapperClass");
   }
+  CHECK_CALLBACK_STATE(isolate);
 
   String& cls_symbol = String::Handle(isolate, Symbols::New(cls_name));
   const Class& cls = Class::Handle(
       isolate, Class::NewNativeWrapper(lib, cls_symbol, field_count));
   if (cls.IsNull()) {
     return Api::NewError(
         "Unable to create native wrapper class : already exists");
   }
   return Api::NewHandle(isolate, cls.raw());
 }
@@ skipping 50 matching lines @@
   return Api::Success(isolate);
 }
 
 
 // --- Exceptions ----
 
 
 DART_EXPORT Dart_Handle Dart_ThrowException(Dart_Handle exception) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   {
     const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
     if (excp.IsNull()) {
       RETURN_TYPE_ERROR(isolate, 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;
   {
     NoGCScope no_gc;
     RawInstance* raw_exception =
         Api::UnwrapInstanceHandle(isolate, exception).raw();
     state->UnwindScopes(isolate->top_exit_frame_info());
     saved_exception = &Instance::Handle(raw_exception);
   }
   Exceptions::Throw(*saved_exception);
   return Api::NewError("Exception was not thrown, internal error");
 }
 
 
 DART_EXPORT Dart_Handle Dart_ReThrowException(Dart_Handle exception,
                                               Dart_Handle stacktrace) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
+  CHECK_CALLBACK_STATE(isolate);
   {
     const Instance& excp = Api::UnwrapInstanceHandle(isolate, exception);
     if (excp.IsNull()) {
       RETURN_TYPE_ERROR(isolate, exception, Instance);
     }
     const Instance& stk = Api::UnwrapInstanceHandle(isolate, stacktrace);
     if (stk.IsNull()) {
       RETURN_TYPE_ERROR(isolate, 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 Instance* saved_stacktrace;
   {
     NoGCScope no_gc;
     RawInstance* raw_exception =
         Api::UnwrapInstanceHandle(isolate, exception).raw();
@@ skipping 96 matching lines @@
   if (source_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, source, String);
   }
   Library& library =
       Library::Handle(isolate, isolate->object_store()->root_library());
   if (!library.IsNull()) {
     const String& library_url = String::Handle(isolate, library.url());
     return Api::NewError("%s: A script has already been loaded from '%s'.",
                          CURRENT_FUNC, library_url.ToCString());
   }
+  CHECK_CALLBACK_STATE(isolate);
+
   library = Library::New(url_str);
   library.set_debuggable(true);
   library.Register();
   isolate->object_store()->set_root_library(library);
 
   const Script& script = Script::Handle(
       isolate, Script::New(url_str, source_str, RawScript::kScriptTag));
   Dart_Handle result;
   CompileSource(isolate, library, script, &result);
   return result;
@@ skipping 23 matching lines @@
                          CURRENT_FUNC, library_url.ToCString());
   }
   if (line_offset < 0) {
     return Api::NewError("%s: argument 'line_offset' must be positive number",
                          CURRENT_FUNC);
   }
   if (col_offset < 0) {
     return Api::NewError("%s: argument 'col_offset' must be positive number",
                          CURRENT_FUNC);
   }
+  CHECK_CALLBACK_STATE(isolate);
 
   library = Library::New(url_str);
   library.set_debuggable(true);
   library.Register();
   isolate->object_store()->set_root_library(library);
 
   const Script& script = Script::Handle(
       isolate, Script::New(url_str, source_str, RawScript::kScriptTag));
   script.SetLocationOffset(line_offset, col_offset);
   Dart_Handle result;
@@ skipping 14 matching lines @@
     return Api::NewError("%s expects parameter 'buffer' to be a script type"
                          " snapshot.", CURRENT_FUNC);
   }
   Library& library =
       Library::Handle(isolate, isolate->object_store()->root_library());
   if (!library.IsNull()) {
     const String& library_url = String::Handle(isolate, library.url());
     return Api::NewError("%s: A script has already been loaded from '%s'.",
                          CURRENT_FUNC, library_url.ToCString());
   }
+  CHECK_CALLBACK_STATE(isolate);
+
   SnapshotReader reader(snapshot->content(),
                         snapshot->length(),
                         snapshot->kind(),
                         isolate);
   const Object& tmp = Object::Handle(isolate, reader.ReadObject());
   if (!tmp.IsLibrary()) {
     return Api::NewError("%s: Unable to deserialize snapshot correctly.",
                          CURRENT_FUNC);
   }
   library ^= tmp.raw();
@@ skipping 24 matching lines @@
 
 
 DART_EXPORT Dart_Handle Dart_CompileAll() {
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   Dart_Handle result;
   const char* msg = CheckIsolateState(isolate);
   if (msg != NULL) {
     return Api::NewError("%s", msg);
   }
+  CHECK_CALLBACK_STATE(isolate);
   CompileAll(isolate, &result);
   return result;
 }
 
 
 DART_EXPORT bool Dart_IsLibrary(Dart_Handle object) {
   return Api::ClassId(object) == kLibraryCid;
 }
 
 
@@ skipping 103 matching lines @@
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const String& url_str = Api::UnwrapStringHandle(isolate, url);
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, url, String);
   }
   const String& source_str = Api::UnwrapStringHandle(isolate, source);
   if (source_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, source, String);
   }
+  CHECK_CALLBACK_STATE(isolate);
+
   Library& library = Library::Handle(isolate, Library::LookupLibrary(url_str));
   if (library.IsNull()) {
     library = Library::New(url_str);
     library.Register();
   } else if (!library.LoadNotStarted()) {
     // The source for this library has either been loaded or is in the
     // process of loading.  Return an error.
     return Api::NewError("%s: library '%s' has already been loaded.",
                          CURRENT_FUNC, url_str.ToCString());
   }
@@ skipping 32 matching lines @@
     RETURN_TYPE_ERROR(isolate, import, Library);
   }
   const Object& prefix_object =
       Object::Handle(isolate, Api::UnwrapHandle(prefix));
   const String& prefix_vm = prefix_object.IsNull()
       ? Symbols::Empty()
       : String::Cast(prefix_object);
   if (prefix_vm.IsNull()) {
     RETURN_TYPE_ERROR(isolate, prefix, String);
   }
+  CHECK_CALLBACK_STATE(isolate);
+
   const String& prefix_symbol =
       String::Handle(isolate, Symbols::New(prefix_vm));
   const Namespace& import_ns = Namespace::Handle(
       Namespace::New(import_vm, Array::Handle(), Array::Handle()));
   if (prefix_vm.Length() == 0) {
     library_vm.AddImport(import_ns);
   } else {
     LibraryPrefix& library_prefix = LibraryPrefix::Handle();
     library_prefix = library_vm.LookupLocalLibraryPrefix(prefix_symbol);
     if (!library_prefix.IsNull()) {
@@ skipping 18 matching lines @@
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
   const String& url_str = Api::UnwrapStringHandle(isolate, url);
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, url, String);
   }
   const String& source_str = Api::UnwrapStringHandle(isolate, source);
   if (source_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, source, String);
   }
+  CHECK_CALLBACK_STATE(isolate);
+
   const Script& script = Script::Handle(
       isolate, Script::New(url_str, source_str, RawScript::kSourceTag));
   Dart_Handle result;
   CompileSource(isolate, lib, script, &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_LoadPatch(Dart_Handle library,
                                        Dart_Handle url,
                                        Dart_Handle patch_source) {
   TIMERSCOPE(time_script_loading);
   Isolate* isolate = Isolate::Current();
   DARTSCOPE(isolate);
   const Library& lib = Api::UnwrapLibraryHandle(isolate, library);
   if (lib.IsNull()) {
     RETURN_TYPE_ERROR(isolate, library, Library);
   }
   const String& url_str = Api::UnwrapStringHandle(isolate, url);
   if (url_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, url, String);
   }
   const String& source_str = Api::UnwrapStringHandle(isolate, patch_source);
   if (source_str.IsNull()) {
     RETURN_TYPE_ERROR(isolate, patch_source, String);
   }
+  CHECK_CALLBACK_STATE(isolate);
+
   const Script& script = Script::Handle(
       isolate, Script::New(url_str, source_str, RawScript::kPatchTag));
   Dart_Handle result;
   CompileSource(isolate, lib, script, &result);
   return result;
 }
 
 
 DART_EXPORT Dart_Handle Dart_SetNativeResolver(
     Dart_Handle library,
@@ skipping 57 matching lines @@
   }
   {
     NoGCScope no_gc;
     RawObject* raw_obj = obj.raw();
     isolate->heap()->SetPeer(raw_obj, peer);
   }
   return Api::Success(isolate);
 }
 
 }  // namespace dart