Remove many calls to Isolate::Current() in the dart embedding api by

runtime/vm/dart_api_impl_test.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 "platform/assert.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_api_state.h"
@@ skipping 145 matching lines @@
   // Equal objects.
   EXPECT_VALID(Dart_IsSame(five, five_again, &same));
   EXPECT(!same);
 
   // Different objects.
   EXPECT_VALID(Dart_IsSame(five, seven, &same));
   EXPECT(!same);
 
   // Non-instance objects.
   {
-    DARTSCOPE_NOCHECKS(Isolate::Current());
+    Isolate* isolate = Isolate::Current();
+    DARTSCOPE_NOCHECKS(isolate);
     const Object& cls1 = Object::Handle(Object::null_class());
     const Object& cls2 = Object::Handle(Object::class_class());
-    Dart_Handle class1 = Api::NewLocalHandle(cls1);
-    Dart_Handle class2 = Api::NewLocalHandle(cls2);
+    Dart_Handle class1 = Api::NewLocalHandle(isolate, cls1);
+    Dart_Handle class2 = Api::NewLocalHandle(isolate, cls2);
 
     EXPECT_VALID(Dart_IsSame(class1, class1, &same));
     EXPECT(same);
 
     EXPECT_VALID(Dart_IsSame(class1, class2, &same));
     EXPECT(!same);
   }
 }
 
 
@@ skipping 940 matching lines @@
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   Dart_EnterScope();
   {
     EXPECT(state->top_scope() != NULL);
     DARTSCOPE_NOCHECKS(isolate);
     const String& str1 = String::Handle(String::New("Test String"));
-    Dart_Handle ref = Api::NewLocalHandle(str1);
+    Dart_Handle ref = Api::NewLocalHandle(isolate, str1);
     String& str2 = String::Handle();
     str2 ^= Api::UnwrapHandle(ref);
     EXPECT(str1.Equals(str2));
   }
   Dart_ExitScope();
   EXPECT(scope == state->top_scope());
 }
 
 
 // Unit test for creating and deleting persistent handles.
 UNIT_TEST_CASE(PersistentHandles) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   Dart_Handle handles[2000];
   Dart_EnterScope();
   {
     DARTSCOPE_NOCHECKS(isolate);
     const String& str1 = String::Handle(String::New(kTestString1));
-    Dart_Handle ref1 = Api::NewLocalHandle(str1);
+    Dart_Handle ref1 = Api::NewLocalHandle(isolate, str1);
     for (int i = 0; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref1);
     }
     Dart_EnterScope();
     const String& str2 = String::Handle(String::New(kTestString2));
-    Dart_Handle ref2 = Api::NewLocalHandle(str2);
+    Dart_Handle ref2 = Api::NewLocalHandle(isolate, str2);
     for (int i = 1000; i < 2000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref2);
     }
     for (int i = 500; i < 1500; i++) {
       Dart_DeletePersistentHandle(handles[i]);
     }
     for (int i = 500; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref2);
     }
     for (int i = 1000; i < 1500; i++) {
@@ skipping 74 matching lines @@
   {
     Dart_EnterScope();
 
     // create an object in new space
     Dart_Handle new_ref = Dart_NewString("new string");
     EXPECT_VALID(new_ref);
 
     // create an object in old space
     Dart_Handle old_ref;
     {
-      DARTSCOPE(Isolate::Current());
+      Isolate* isolate = Isolate::Current();
+      DARTSCOPE(isolate);
       const String& str =
           String::Handle(String::New("old string", Heap::kOld));
-      old_ref = Api::NewLocalHandle(str);
+      old_ref = Api::NewLocalHandle(isolate, str);
       EXPECT_VALID(old_ref);
     }
 
     // create a weak ref to the new space object
     weak_new_ref = Dart_NewWeakPersistentHandle(new_ref, NULL, NULL);
     EXPECT_VALID(weak_new_ref);
     EXPECT(!Dart_IsNull(weak_new_ref));
 
     // create a weak ref to the old space object
     weak_old_ref = Dart_NewWeakPersistentHandle(old_ref, NULL, NULL);
@@ skipping 112 matching lines @@
   EXPECT(Dart_IsNull(weak2));
 
   Dart_Handle weak3 = Dart_Null();
   EXPECT(Dart_IsNull(weak3));
 
   Dart_Handle weak4 = Dart_Null();
   EXPECT(Dart_IsNull(weak4));
 
   Dart_EnterScope();
   {
-    DARTSCOPE(Isolate::Current());
+    Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
     String& str = String::Handle();
 
     str ^= String::New("strongly reachable", Heap::kOld);
-    strong = Dart_NewPersistentHandle(Api::NewLocalHandle(str));
+    strong = Dart_NewPersistentHandle(Api::NewLocalHandle(isolate, str));
     EXPECT_VALID(strong);
     EXPECT(!Dart_IsNull(strong));
 
     str ^= String::New("weakly reachable 1", Heap::kOld);
-    weak1 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    weak1 = Dart_NewWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT_VALID(weak1);
     EXPECT(!Dart_IsNull(weak1));
 
     str ^= String::New("weakly reachable 2", Heap::kOld);
-    weak2 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    weak2 = Dart_NewWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT_VALID(weak2);
     EXPECT(!Dart_IsNull(weak2));
 
     str ^= String::New("weakly reachable 3", Heap::kOld);
-    weak3 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    weak3 = Dart_NewWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT_VALID(weak3);
     EXPECT(!Dart_IsNull(weak3));
 
     str ^= String::New("weakly reachable 4", Heap::kOld);
-    weak4 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    weak4 = Dart_NewWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT_VALID(weak4);
     EXPECT(!Dart_IsNull(weak4));
   }
   Dart_ExitScope();
 
   EXPECT_VALID(strong);
 
   EXPECT_VALID(weak1);
   EXPECT_VALID(weak2);
   EXPECT_VALID(weak3);
@@ skipping 133 matching lines @@
 }
 
 
 TEST_CASE(PrologueWeakPersistentHandles) {
   Dart_Handle old_pwph = Dart_Null();
   EXPECT(Dart_IsNull(old_pwph));
   Dart_Handle new_pwph = Dart_Null();
   EXPECT(Dart_IsNull(new_pwph));
   Dart_EnterScope();
   {
-    DARTSCOPE(Isolate::Current());
+    Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
     String& str = String::Handle();
     str ^= String::New("new space prologue weak", Heap::kNew);
-    new_pwph = Dart_NewPrologueWeakPersistentHandle(Api::NewLocalHandle(str),
-                                                    NULL,
-                                                    NULL);
+    new_pwph = Dart_NewPrologueWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT_VALID(new_pwph);
     EXPECT(!Dart_IsNull(new_pwph));
     str ^= String::New("old space prologue weak", Heap::kOld);
-    old_pwph = Dart_NewPrologueWeakPersistentHandle(Api::NewLocalHandle(str),
-                                                    NULL,
-                                                    NULL);
+    old_pwph = Dart_NewPrologueWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT_VALID(old_pwph);
     EXPECT(!Dart_IsNull(old_pwph));
     str ^= String::null();
   }
   Dart_ExitScope();
   EXPECT_VALID(new_pwph);
   EXPECT(!Dart_IsNull(new_pwph));
   EXPECT(Dart_IsPrologueWeakPersistentHandle(new_pwph));
   EXPECT_VALID(old_pwph);
   EXPECT(!Dart_IsNull(old_pwph));
@@ skipping 35 matching lines @@
 
   Dart_Handle weak2 = Dart_Null();
   EXPECT(Dart_IsNull(weak2));
 
   Dart_Handle weak3 = Dart_Null();
   EXPECT(Dart_IsNull(weak3));
 
 
   Dart_EnterScope();
   {
-    DARTSCOPE(Isolate::Current());
+    Isolate* isolate = Isolate::Current();
+    DARTSCOPE(isolate);
     String& str = String::Handle();
 
     str ^= String::New("strongly reachable", Heap::kOld);
-    strong = Dart_NewPersistentHandle(Api::NewLocalHandle(str));
+    strong = Dart_NewPersistentHandle(Api::NewLocalHandle(isolate, str));
     EXPECT(!Dart_IsNull(strong));
     EXPECT_VALID(strong);
 
     str ^= String::New("weakly reachable 1", Heap::kOld);
-    weak1 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    weak1 = Dart_NewWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT(!Dart_IsNull(weak1));
     EXPECT_VALID(weak1);
 
     str ^= String::New("weakly reachable 2", Heap::kOld);
-    weak2 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    weak2 = Dart_NewWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT(!Dart_IsNull(weak2));
     EXPECT_VALID(weak2);
 
     str ^= String::New("weakly reachable 3", Heap::kOld);
-    weak3 = Dart_NewWeakPersistentHandle(Api::NewLocalHandle(str), NULL, NULL);
+    weak3 = Dart_NewWeakPersistentHandle(
+        Api::NewLocalHandle(isolate, str), NULL, NULL);
     EXPECT(!Dart_IsNull(weak3));
     EXPECT_VALID(weak3);
   }
   Dart_ExitScope();
 
   EXPECT_VALID(strong);
 
   EXPECT_VALID(weak1);
   EXPECT_VALID(weak2);
   EXPECT_VALID(weak3);
@@ skipping 300 matching lines @@
   ApiLocalScope* scope = state->top_scope();
   Dart_Handle handles[300];
   {
     DARTSCOPE_NOCHECKS(isolate);
     Smi& val = Smi::Handle();
 
     // Start a new scope and allocate some local handles.
     Dart_EnterScope();
     for (int i = 0; i < 100; i++) {
       val ^= Smi::New(i);
-      handles[i] = Api::NewLocalHandle(val);
+      handles[i] = Api::NewLocalHandle(isolate, val);
     }
     EXPECT_EQ(100, state->CountLocalHandles());
     for (int i = 0; i < 100; i++) {
       val ^= Api::UnwrapHandle(handles[i]);
       EXPECT_EQ(i, val.Value());
     }
     // Start another scope and allocate some more local handles.
     {
       Dart_EnterScope();
       for (int i = 100; i < 200; i++) {
         val ^= Smi::New(i);
-        handles[i] = Api::NewLocalHandle(val);
+        handles[i] = Api::NewLocalHandle(isolate, val);
       }
       EXPECT_EQ(200, state->CountLocalHandles());
       for (int i = 100; i < 200; i++) {
         val ^= Api::UnwrapHandle(handles[i]);
         EXPECT_EQ(i, val.Value());
       }
 
       // Start another scope and allocate some more local handles.
       {
         Dart_EnterScope();
         for (int i = 200; i < 300; i++) {
           val ^= Smi::New(i);
-          handles[i] = Api::NewLocalHandle(val);
+          handles[i] = Api::NewLocalHandle(isolate, val);
         }
         EXPECT_EQ(300, state->CountLocalHandles());
         for (int i = 200; i < 300; i++) {
           val ^= Api::UnwrapHandle(handles[i]);
           EXPECT_EQ(i, val.Value());
         }
         EXPECT_EQ(300, state->CountLocalHandles());
         VERIFY_ON_TRANSITION;
         Dart_ExitScope();
       }
@@ skipping 16 matching lines @@
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
   {
     // Start a new scope and allocate some memory.
     Dart_EnterScope();
     for (int i = 0; i < 100; i++) {
-      Api::Allocate(16);
+      Api::Allocate(isolate, 16);
     }
     EXPECT_EQ(1600, state->ZoneSizeInBytes());
     // Start another scope and allocate some more memory.
     {
       Dart_EnterScope();
       for (int i = 0; i < 100; i++) {
-        Api::Allocate(16);
+        Api::Allocate(isolate, 16);
       }
       EXPECT_EQ(3200, state->ZoneSizeInBytes());
       {
         // Start another scope and allocate some more memory.
         {
           Dart_EnterScope();
           for (int i = 0; i < 200; i++) {
-            Api::Allocate(16);
+            Api::Allocate(isolate, 16);
           }
           EXPECT_EQ(6400, state->ZoneSizeInBytes());
           Dart_ExitScope();
         }
       }
       EXPECT_EQ(3200, state->ZoneSizeInBytes());
       Dart_ExitScope();
     }
     EXPECT_EQ(1600, state->ZoneSizeInBytes());
     Dart_ExitScope();
@@ skipping 1250 matching lines @@
   dart_arguments[0] = Dart_NewInteger(1);
   result = Dart_InvokeClosure(retobj, 1, dart_arguments);
   EXPECT(Dart_IsError(result));
   EXPECT(Dart_ErrorHasException(result));
 }
 
 
 void ExceptionNative(Dart_NativeArguments args) {
   Dart_Handle param = Dart_GetNativeArgument(args, 0);
   Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
-  char* str = reinterpret_cast<char*>(Api::Allocate(1024));
-  str[0] = 0;
   Dart_ThrowException(param);
   UNREACHABLE();
 }
 
 
 static Dart_NativeFunction native_lookup(Dart_Handle name, int argument_count) {
   return reinterpret_cast<Dart_NativeFunction>(&ExceptionNative);
 }
 
 
@@ skipping 185 matching lines @@
   EXPECT_VALID(result);
   EXPECT(!is_instance);
 
   // Check that error is returned if null is passed as a class argument.
   result = Dart_ObjectIsType(null, null, &is_instance);
   EXPECT(Dart_IsError(result));
 }
 
 
 TEST_CASE(NullReceiver) {
-  DARTSCOPE_NOCHECKS(Isolate::Current());
+  Isolate* isolate = Isolate::Current();
+  DARTSCOPE_NOCHECKS(isolate);
 
   Dart_Handle function_name = Dart_NewString("toString");
   const int number_of_arguments = 0;
-  Dart_Handle null_receiver = Api::NewLocalHandle(Object::Handle());
+  Dart_Handle null_receiver = Api::NewLocalHandle(isolate, Object::Handle());
   Dart_Handle result = Dart_InvokeDynamic(null_receiver,
                                           function_name,
                                           number_of_arguments,
                                           NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsString(result));
 
   // Should throw a NullPointerException. Disabled due to bug 5415268.
   /*
     Dart_Handle function_name2 = Dart_NewString("NoNoNo");
     result = Dart_InvokeDynamic(null_receiver,
     function_name2,
     number_of_arguments,
     dart_arguments);
     EXPECT(Dart_IsError(result));
     EXPECT(Dart_ErrorHasException(result)); */
 }
 
 
 static Dart_Handle library_handler(Dart_LibraryTag tag,
                                    Dart_Handle library,
                                    Dart_Handle url,
                                    Dart_Handle import_url_map) {
   if (tag == kCanonicalizeUrl) {
     return url;
   }
-  return Api::Success();
+  return Api::Success(Isolate::Current());
 }
 
 
 TEST_CASE(LoadScript) {
   const char* kScriptChars =
       "main() {"
       "  return 12345;"
       "}";
   Dart_Handle url = Dart_NewString(TestCase::url());
   Dart_Handle source = Dart_NewString(kScriptChars);
@@ skipping 87 matching lines @@
       EXPECT_STREQ("abclaladef/extra_weird.dart", cstr);
       break;
     case 4:
       EXPECT_STREQ("winnerwinner", cstr);
       break;
     default:
       EXPECT(false);
       return Api::NewError("invalid callback");
   }
   index += 1;
-  return Api::Success();
+  return Api::Success(Isolate::Current());
 }
 
 
 TEST_CASE(LoadImportScript) {
   const char* kScriptChars =
       "#import('$GOOGLE3/weird.dart');"
       "#import('abc${ABC}def');"
       "#import('${var1}$var2');"
       "#import('abc${ABC}def/extra_weird.dart');"
       "#import('$var2$var2');"
@@ skipping 1053 matching lines @@
   // We should have received the expected number of interrupts.
   EXPECT_EQ(kInterruptCount, interrupt_count);
 
   // Give the spawned thread enough time to properly exit.
   Isolate::SetInterruptCallback(saved);
 }
 
 #endif  // defined(TARGET_ARCH_IA32) || defined(TARGET_ARCH_X64).
 
 }  // namespace dart