Use ASSERT instead of CHECK_ISOLATE in cases where we derive the isolate from the native Arguments …

runtime/vm/dart_api_impl.cc

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 
 #include "platform/assert.h"
 #include "vm/bigint_operations.h"
@@ skipping 3912 matching lines @@
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if ((arg_index < 0) || (arg_index >= arguments->NativeArgCount())) {
     return Api::NewError(
         "%s: argument 'arg_index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->NativeArgCount() - 1, arg_index);
   }
   if (field_values == NULL) {
     RETURN_NULL_ERROR(field_values);
   }
   Isolate* isolate = arguments->isolate();
-  CHECK_ISOLATE(isolate);
+  ASSERT(isolate != NULL);

[Ivan Posva, 2014/03/27 21:05:43]

How about ASSERT(isolate == Isolate:Current())?

[siva, 2014/03/27 21:55:46]

Good point, I will modify the asserts to this form.

On 2014/03/27 21:05:43, Ivan Posva wrote:

   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   if (obj.IsNull()) {
     for (intptr_t i = 0; i < num_fields; i++) {
       field_values[i] = 0;
     }
     return Api::Success();
   }
   if (!obj.IsInstance()) {
     return Api::NewError("%s expects argument at index '%d' to be of"
                          " type Instance.", CURRENT_FUNC, arg_index);
   }
   const Instance& instance = Instance::Cast(obj);
   uint16_t field_count = instance.NumNativeFields();
   if (num_fields != field_count) {
     return Api::NewError(
         "%s: invalid 'field_values' array specified for returning field values",
         CURRENT_FUNC);
   }
   instance.GetNativeFields(num_fields, field_values);
   return Api::Success();
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeReceiver(Dart_NativeArguments args,
                                                intptr_t* value) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  Isolate* isolate = arguments->isolate();
-  CHECK_ISOLATE(isolate);
+  ASSERT(arguments->isolate() != NULL);
   if (value == NULL) {
     RETURN_NULL_ERROR(value);
   }
   if (Api::GetNativeReceiver(arguments, value)) {
     return Api::Success();
   }
   return Api::NewError("%s expects receiver argument to be non-null and of"
                        " type Instance.", CURRENT_FUNC);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeStringArgument(Dart_NativeArguments args,
                                                      int arg_index,
                                                      void** peer) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   Isolate* isolate = arguments->isolate();
-  CHECK_ISOLATE(isolate);
+  ASSERT(isolate != NULL);
   if (Api::StringGetPeerHelper(arguments, arg_index, peer)) {
     return Api::Success();
   }
   *peer = NULL;
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(arg_index);
   if (RawObject::IsStringClassId(obj.GetClassId())) {
     return Api::NewHandle(isolate, obj.raw());
   }
   if (obj.IsNull()) {
     return Api::Null();
   }
   return Api::NewError("%s expects argument to be of"
                        " type String.", CURRENT_FUNC);
 }
 
 
 DART_EXPORT Dart_Handle Dart_GetNativeIntegerArgument(Dart_NativeArguments args,
                                                       int index,
                                                       int64_t* value) {
   TRACE_API_CALL(CURRENT_FUNC);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if ((index < 0) || (index >= arguments->NativeArgCount())) {
     return Api::NewError(
         "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
   }
   Isolate* isolate = arguments->isolate();
+  ASSERT(isolate != NULL);
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(index);
   intptr_t cid = obj.GetClassId();
   if (cid == kSmiCid) {
     *value = Smi::Cast(obj).Value();
     return Api::Success();
   }
   if (cid == kMintCid) {
     *value = Mint::Cast(obj).value();
@@ skipping 37 matching lines @@
                                                      int index,
                                                      double* value) {
   TRACE_API_CALL(CURRENT_FUNC);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   if ((index < 0) || (index >= arguments->NativeArgCount())) {
     return Api::NewError(
         "%s: argument 'index' out of range. Expected 0..%d but saw %d.",
         CURRENT_FUNC, arguments->NativeArgCount() - 1, index);
   }
   Isolate* isolate = arguments->isolate();
+  ASSERT(isolate != NULL);
   REUSABLE_OBJECT_HANDLESCOPE(isolate);
   Object& obj = isolate->ObjectHandle();
   obj = arguments->NativeArgAt(index);
   intptr_t cid = obj.GetClassId();
   if (cid == kDoubleCid) {
     *value = Double::Cast(obj).value();
     return Api::Success();
   }
   if (cid == kSmiCid) {
     *value = Smi::Cast(obj).AsDoubleValue();
     return Api::Success();
   }
   if (cid == kMintCid) {
     *value = Mint::Cast(obj).AsDoubleValue();
     return Api::Success();
   }
   if (cid == kBigintCid) {
     *value = Bigint::Cast(obj).AsDoubleValue();
     return Api::Success();
   }
   return Api::NewError(
       "%s: argument %d is not a Double argument.",
       CURRENT_FUNC, index);
 }
 
 
 DART_EXPORT void Dart_SetReturnValue(Dart_NativeArguments args,
                                      Dart_Handle retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  Isolate* isolate = arguments->isolate();
-  CHECK_ISOLATE(isolate);
+  ASSERT(arguments->isolate() != NULL);
   if ((retval != Api::Null()) && (!Api::IsInstance(retval))) {
     const Object& ret_obj = Object::Handle(Api::UnwrapHandle(retval));
     FATAL1("Return value check failed: saw '%s' expected a dart Instance.",
            ret_obj.ToCString());
   }
   ASSERT(retval != 0);
   Api::SetReturnValue(arguments, retval);
 }
 
 
 DART_EXPORT void Dart_SetWeakHandleReturnValue(Dart_NativeArguments args,
                                                Dart_WeakPersistentHandle rval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
+#if defined(DEBUG)
   Isolate* isolate = arguments->isolate();
-  CHECK_ISOLATE(isolate);
+  ASSERT(isolate != NULL);
   ASSERT(isolate->api_state() != NULL &&
          (isolate->api_state()->IsValidWeakPersistentHandle(rval) ||
           isolate->api_state()->IsValidPrologueWeakPersistentHandle(rval)));
+#endif

[Ivan Posva, 2014/03/27 21:05:43]

#endif  // defined(DEBUG)

   Api::SetWeakHandleReturnValue(arguments, rval);
 }
 
 
 // --- Environment ---
 DART_EXPORT Dart_Handle Dart_SetEnvironmentCallback(
     Dart_EnvironmentCallback callback) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
   isolate->set_environment_callback(callback);
   return Api::Success();
 }
 
 
 // --- Scripts and Libraries ---
 DART_EXPORT void Dart_SetBooleanReturnValue(Dart_NativeArguments args,
                                             bool retval) {
   TRACE_API_CALL(CURRENT_FUNC);
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
   arguments->SetReturn(Bool::Get(retval));
 }
 
 
 DART_EXPORT void Dart_SetIntegerReturnValue(Dart_NativeArguments args,
                                             int64_t retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
-  Isolate* isolate = arguments->isolate();
-  CHECK_ISOLATE(isolate);
+  ASSERT(arguments->isolate() != NULL);
   if (Smi::IsValid64(retval)) {
     Api::SetSmiReturnValue(arguments, retval);
   } else {
     // Slow path for Mints and Bigints.
-    ASSERT_CALLBACK_STATE(isolate);
+    ASSERT_CALLBACK_STATE(arguments->isolate());
     Api::SetIntegerReturnValue(arguments, retval);
   }
 }
 
 
 DART_EXPORT void Dart_SetDoubleReturnValue(Dart_NativeArguments args,
                                            double retval) {
   NativeArguments* arguments = reinterpret_cast<NativeArguments*>(args);
+#if defined(DEBUG)
   Isolate* isolate = arguments->isolate();
-  CHECK_ISOLATE(isolate);
+  ASSERT(isolate != NULL);
   ASSERT_CALLBACK_STATE(isolate);
+#endif
   Api::SetDoubleReturnValue(arguments, retval);
 }
 
 
 // --- Scripts and Libraries ---
 
 DART_EXPORT Dart_Handle Dart_SetLibraryTagHandler(
     Dart_LibraryTagHandler handler) {
   Isolate* isolate = Isolate::Current();
   CHECK_ISOLATE(isolate);
@@ skipping 491 matching lines @@
 
 
 DART_EXPORT void Dart_RegisterRootServiceRequestCallback(
     const char* name,
     Dart_ServiceRequestCallback callback,
     void* user_data) {
   Service::RegisterRootEmbedderCallback(name, callback, user_data);
 }
 
 }  // namespace dart