- Ensure that HandleScope is initialized with a thread. (Remove

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 "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "include/dart_tools_api.h"
 #include "platform/assert.h"
@@ skipping 598 matching lines @@
   EXPECT(!Dart_IdentityEquals(five, mint));
   EXPECT(!Dart_IdentityEquals(abc, xyz));
 
   // Case where identical() is not the same as pointer equality.
   Dart_Handle nan1 = Dart_NewDouble(NAN);
   Dart_Handle nan2 = Dart_NewDouble(NAN);
   EXPECT(Dart_IdentityEquals(nan1, nan2));
 
   // Non-instance objects.
   {
-    Isolate* isolate = Isolate::Current();
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     Dart_Handle lib1 = Dart_LookupLibrary(dart_core);
     Dart_Handle lib2 = Dart_LookupLibrary(dart_mirrors);
 
     EXPECT(Dart_IdentityEquals(lib1, lib1));
     EXPECT(Dart_IdentityEquals(lib2, lib2));
     EXPECT(!Dart_IdentityEquals(lib1, lib2));
 
     // Mix instance and non-instance.
     EXPECT(!Dart_IdentityEquals(lib1, nan1));
     EXPECT(!Dart_IdentityEquals(nan1, lib1));
@@ skipping 24 matching lines @@
 
   // Note abc and abc_again are not required to have equal identity hashes.
 
   // Case where identical() is not the same as pointer equality.
   Dart_Handle nan1 = Dart_NewDouble(NAN);
   Dart_Handle nan2 = Dart_NewDouble(NAN);
   EXPECT_EQ(Dart_IdentityHash(nan1), Dart_IdentityHash(nan2));
 
   // Non-instance objects.
   {
-    Isolate* isolate = Isolate::Current();
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     Dart_Handle lib1 = Dart_LookupLibrary(dart_core);
     Dart_Handle lib2 = Dart_LookupLibrary(dart_mirrors);
 
     EXPECT_EQ(Dart_IdentityHash(lib1), Dart_IdentityHash(lib1));
     EXPECT_EQ(Dart_IdentityHash(lib2), Dart_IdentityHash(lib2));
   }
 }
 
 
 TEST_CASE(ObjectEquals) {
@@ skipping 491 matching lines @@
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT_EQ(40, peer8);
   EXPECT_EQ(41, peer16);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT_EQ(80, peer8);
   EXPECT_EQ(82, peer16);
 }
 
 
 TEST_CASE(ExternalStringPretenure) {
-  Isolate* isolate = Isolate::Current();
   {
     Dart_EnterScope();
     static const uint8_t big_data8[16*MB] = {0, };
     Dart_Handle big8 = Dart_NewExternalLatin1String(
         big_data8,
         ARRAY_SIZE(big_data8),
         NULL,
         NULL);
     EXPECT_VALID(big8);
     static const uint16_t big_data16[16*MB/2] = {0, };
@@ skipping 10 matching lines @@
         NULL);
     EXPECT_VALID(small8);
     static const uint16_t small_data16[] = {'b', 'a', 'r'};
     Dart_Handle small16 = Dart_NewExternalUTF16String(
         small_data16,
         ARRAY_SIZE(small_data16),
         NULL,
         NULL);
     EXPECT_VALID(small16);
     {
-      DARTSCOPE(isolate);
+      DARTSCOPE(Thread::Current());
       String& handle = String::Handle();
       handle ^= Api::UnwrapHandle(big8);
       EXPECT(handle.IsOld());
       handle ^= Api::UnwrapHandle(big16);
       EXPECT(handle.IsOld());
       handle ^= Api::UnwrapHandle(small8);
       EXPECT(handle.IsNew());
       handle ^= Api::UnwrapHandle(small16);
       EXPECT(handle.IsNew());
     }
     Dart_ExitScope();
   }
 }
 
 
 TEST_CASE(ExternalTypedDataPretenure) {
-  Isolate* isolate = Isolate::Current();
   {
     Dart_EnterScope();
     static const int kBigLength = 16*MB/8;
     int64_t* big_data = new int64_t[kBigLength]();
     Dart_Handle big = Dart_NewExternalTypedData(
         Dart_TypedData_kInt64,
         big_data,
         kBigLength);
     EXPECT_VALID(big);
     static const int kSmallLength = 16*KB/8;
     int64_t* small_data = new int64_t[kSmallLength]();
     Dart_Handle small = Dart_NewExternalTypedData(
         Dart_TypedData_kInt64,
         small_data,
         kSmallLength);
     EXPECT_VALID(small);
     {
-      DARTSCOPE(isolate);
+      DARTSCOPE(Thread::Current());
       ExternalTypedData& handle = ExternalTypedData::Handle();
       handle ^= Api::UnwrapHandle(big);
       EXPECT(handle.IsOld());
       handle ^= Api::UnwrapHandle(small);
       EXPECT(handle.IsNew());
     }
     Dart_ExitScope();
     delete[] big_data;
     delete[] small_data;
   }
@@ skipping 1106 matching lines @@
   TestIsolateScope __test_isolate__;
 
   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(isolate);
+    DARTSCOPE(Thread::Current());
     const String& str1 = String::Handle(String::New("Test String"));
     Dart_Handle ref = Api::NewHandle(isolate, str1.raw());
     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_PersistentHandle handles[2000];
   Dart_EnterScope();
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     Dart_Handle ref1 = Api::NewHandle(isolate, String::New(kTestString1));
     for (int i = 0; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref1);
     }
     Dart_EnterScope();
     Dart_Handle ref2 = Api::NewHandle(isolate, String::New(kTestString2));
     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++) {
       handles[i] = Dart_NewPersistentHandle(ref1);
     }
     VERIFY_ON_TRANSITION;
     Dart_ExitScope();
   }
   Dart_ExitScope();
   {
     StackZone zone(isolate);
-    HANDLESCOPE(isolate);
+    HANDLESCOPE(Thread::Current());
     for (int i = 0; i < 500; i++) {
       String& str = String::Handle();
       str ^= PersistentHandle::Cast(handles[i])->raw();
       EXPECT(str.Equals(kTestString1));
     }
     for (int i = 500; i < 1000; i++) {
       String& str = String::Handle();
       str ^= PersistentHandle::Cast(handles[i])->raw();
       EXPECT(str.Equals(kTestString2));
     }
@@ skipping 16 matching lines @@
 
 // Test that we are able to create a persistent handle from a
 // persistent handle.
 UNIT_TEST_CASE(NewPersistentHandle_FromPersistentHandle) {
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
-  DARTSCOPE(isolate);
+  DARTSCOPE(Thread::Current());
 
   // Start with a known persistent handle.
   Dart_PersistentHandle obj1 = Dart_NewPersistentHandle(Dart_True());
   EXPECT(state->IsValidPersistentHandle(obj1));
 
   // And use it to allocate a second persistent handle.
   Dart_Handle obj2 = Dart_HandleFromPersistent(obj1);
   Dart_PersistentHandle obj3 = Dart_NewPersistentHandle(obj2);
   EXPECT(state->IsValidPersistentHandle(obj3));
 
@@ skipping 10 matching lines @@
 // Test that we can assign to a persistent handle.
 UNIT_TEST_CASE(AssignToPersistentHandle) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestIsolateScope __test_isolate__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
-  DARTSCOPE(isolate);
+  DARTSCOPE(Thread::Current());
   String& str = String::Handle();
 
   // Start with a known persistent handle.
   Dart_Handle ref1 = Api::NewHandle(isolate, String::New(kTestString1));
   Dart_PersistentHandle obj = Dart_NewPersistentHandle(ref1);
   EXPECT(state->IsValidPersistentHandle(obj));
   str ^= PersistentHandle::Cast(obj)->raw();
   EXPECT(str.Equals(kTestString1));
 
   // Now create another local handle and assign it to the persistent handle.
@@ skipping 59 matching lines @@
     Dart_EnterScope();
 
     // Create an object in new space.
     Dart_Handle new_ref = NewString("new string");
     EXPECT_VALID(new_ref);
 
     // Create an object in old space.
     Dart_Handle old_ref;
     {
       Isolate* isolate = Isolate::Current();
-      DARTSCOPE(isolate);
+      DARTSCOPE(Thread::Current());
       old_ref = Api::NewHandle(isolate, String::New("old string", Heap::kOld));
       EXPECT_VALID(old_ref);
     }
 
     // Create a weak ref to the new space object.
     weak_new_ref = Dart_NewWeakPersistentHandle(new_ref,
                                                 NULL,
                                                 0,
                                                 WeakPersistentHandleCallback);
     EXPECT_VALID(AsHandle(weak_new_ref));
@@ skipping 234 matching lines @@
     // ... but the object is still alive and not yet promoted, so external size
     // in new space is still above the limit. Thus, even the following tiny
     // external allocation will trigger another scavenge.
     Dart_WeakPersistentHandle trigger =
       Dart_NewWeakPersistentHandle(obj, NULL, 1, NopCallback);
     EXPECT_VALID(AsHandle(trigger));
     Dart_DeleteWeakPersistentHandle(isolate, trigger);
     // After the two scavenges above, 'obj' should now be promoted, hence its
     // external size charged to old space.
     {
-      DARTSCOPE(Isolate::Current());
-      String& handle = String::Handle();
+      DARTSCOPE(thread);
+      String& handle = String::Handle(thread->zone());
       handle ^= Api::UnwrapHandle(obj);
       EXPECT(handle.IsOld());
     }
     EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
     EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak1ExternalSize / kWordSize);
     Dart_ExitScope();
   }
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
@@ skipping 89 matching lines @@
 }
 
 
 TEST_CASE(ObjectGroups) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
 
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NopCallback);
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong)));
 
     weak1 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kOld)),
@@ skipping 221 matching lines @@
 }
 
 
 TEST_CASE(DuplicateWeakReferenceSetEntries) {
   Isolate* isolate = Isolate::Current();
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle weak = NULL;  // A weak handle to strong.
 
   Dart_EnterScope();
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
 
     // Strong handle to keep the reference set alive.
     Dart_Handle local = Api::NewHandle(isolate, String::New("string"));
     strong = Dart_NewPersistentHandle(local);
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     // Corresponding weak handle to use as key and duplicated value.
     weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NopCallback);
     EXPECT_VALID(AsHandle(weak));
     EXPECT(!Dart_IsNull(AsHandle(weak)));
@@ skipping 32 matching lines @@
   } else if (handle == new_pwph) {
     new_pwph = NULL;
   }
 }
 
 
 TEST_CASE(PrologueWeakPersistentHandles) {
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     new_pwph = Dart_NewPrologueWeakPersistentHandle(
         Api::NewHandle(isolate,
                        String::New("new space prologue weak", Heap::kNew)),
         NULL, 0, PrologueWeakHandleCallback);
     EXPECT_VALID(AsHandle(new_pwph));
     EXPECT(!Dart_IsNull(AsHandle(new_pwph)));
     old_pwph = Dart_NewPrologueWeakPersistentHandle(
         Api::NewHandle(isolate,
                        String::New("old space prologue weak", Heap::kOld)),
         NULL, 0, PrologueWeakHandleCallback);
@@ skipping 77 matching lines @@
 }
 
 
 TEST_CASE(ImplicitReferencesOldSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
 
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NopCallback);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
@@ skipping 90 matching lines @@
 
 
 TEST_CASE(ImplicitReferencesNewSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
 
     Dart_Handle local = Api::NewHandle(
         isolate, String::New("strongly reachable", Heap::kOld));
     strong = Dart_NewPersistentHandle(local);
     strong_weak = Dart_NewWeakPersistentHandle(local, NULL, 0, NopCallback);
 
     EXPECT(!Dart_IsNull(AsHandle(strong)));
     EXPECT_VALID(AsHandle(strong));
     EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
     EXPECT_VALID(AsHandle(strong_weak));
@@ skipping 243 matching lines @@
 UNIT_TEST_CASE(LocalHandles) {
   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[300];
   {
     StackZone zone(isolate);
-    HANDLESCOPE(isolate);
+    HANDLESCOPE(Thread::Current());
     Smi& val = Smi::Handle();
 
     // Start a new scope and allocate some local handles.
     Dart_EnterScope();
     for (int i = 0; i < 100; i++) {
       handles[i] = Api::NewHandle(isolate, Smi::New(i));
     }
     EXPECT_EQ(100, state->CountLocalHandles());
     for (int i = 0; i < 100; i++) {
       val ^= Api::UnwrapHandle(handles[i]);
@@ skipping 750 matching lines @@
       kNumNativeFields);
   EXPECT_VALID(result);
   result = Dart_FinalizeLoading(false);
   EXPECT_VALID(result);
 
   // Load up a test script in the test library.
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
-  DARTSCOPE(Isolate::Current());
+  DARTSCOPE(Thread::Current());
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
@@ skipping 49 matching lines @@
   Dart_Handle result;
   const int kNumNativeFields = 2;
 
   // Load up a test script in the test library.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars,
                                              native_field_lookup);
 
   // Invoke a function which returns an object of type NativeFields.
   result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
-  DARTSCOPE(Isolate::Current());
+  DARTSCOPE(Thread::Current());
   Instance& obj = Instance::Handle();
   obj ^= Api::UnwrapHandle(result);
   const Class& cls = Class::Handle(obj.clazz());
   // We expect the newly created "NativeFields" object to have
   // 2 dart instance fields (fld1, fld2) and a reference to the native fields.
   // Hence the size of an instance of "NativeFields" should be
   // (1 + 2) * kWordSize + size of object header.
   // We check to make sure the instance size computed by the VM matches
   // our expectations.
   intptr_t header_size = sizeof(RawObject);
@@ skipping 323 matching lines @@
       "  static const int fld4 = 10;\n"
       "}\n"
       "NativeFields testMain1() {\n"
       "  NativeFields obj = new NativeFields(10, 20);\n"
       "  return obj;\n"
       "}\n"
       "Function testMain2() {\n"
       "  return () {};\n"
       "}\n";
   Dart_Handle result;
-  DARTSCOPE(Isolate::Current());
+  DARTSCOPE(Thread::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns an object of type NativeFields.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, NULL);
   EXPECT_VALID(retobj);
 
   // Now access and set various native instance fields of the returned object.
   // All of these tests are expected to return failure as there are no
@@ skipping 57 matching lines @@
       "  var port = new RawReceivePort();\n"
       "  var obj = new Test(1,2);\n"
       "  var msg = [obj, port.sendPort];\n"
       "  var snd = Isolate.spawn(echo, msg);\n"
       "  port.handler = (msg) {\n"
       "    port.close();\n"
       "    print('from worker ${msg}');\n"
       "  };\n"
       "}\n";
 
-  DARTSCOPE(Isolate::Current());
+  DARTSCOPE(Thread::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke 'main' which should spawn an isolate and try to send an
   // object with native fields over to the spawned isolate. This
   // should result in an unhandled exception which is checked.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT(Dart_IsError(retobj));
 }
@@ skipping 680 matching lines @@
       "  static const int fld4 = 10;\n"
       "}\n"
       "Function testMain1() {\n"
       "  InvokeClosure obj = new InvokeClosure(10, 20);\n"
       "  return obj.method1(10);\n"
       "}\n"
       "Function testMain2() {\n"
       "  return InvokeClosure.method2(10);\n"
       "}\n";
   Dart_Handle result;
-  DARTSCOPE(Isolate::Current());
+  DARTSCOPE(Thread::Current());
 
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
 
   // Invoke a function which returns a closure.
   Dart_Handle retobj = Dart_Invoke(lib, NewString("testMain1"), 0, NULL);
   EXPECT_VALID(retobj);
 
   EXPECT(Dart_IsClosure(retobj));
   EXPECT(!Dart_IsClosure(Dart_NewInteger(101)));
@@ skipping 2572 matching lines @@
 }
 
 
 // Allocates an object in new space and assigns it a peer.  Allows the
 // peer referent to be garbage collected and checks that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneNewSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     Dart_Handle str = NewString("a string");
     EXPECT_VALID(str);
     EXPECT(Dart_IsString(str));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* out = &out;
     EXPECT_VALID(Dart_GetPeer(str, &out));
     EXPECT(out == NULL);
     int peer = 1234;
     EXPECT_VALID(Dart_SetPeer(str, &peer));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 52 matching lines @@
 }
 
 
 // Allocates two objects in new space and assigns them a peer.  Allow
 // the peer referents to be garbage collected and check that the count
 // of peer objects is decremented by two.
 TEST_CASE(CollectTwoNewSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     Dart_Handle s1 = NewString("s1");
     EXPECT_VALID(s1);
     EXPECT(Dart_IsString(s1));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* o1 = &o1;
     EXPECT(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == NULL);
     int p1 = 1234;
     EXPECT_VALID(Dart_SetPeer(s1, &p1));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 63 matching lines @@
   EXPECT(out == NULL);
   int peer = 1234;
   EXPECT_VALID(Dart_SetPeer(str, &peer));
   out = &out;
   EXPECT(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   isolate->heap()->CollectGarbage(Heap::kNew);
   isolate->heap()->CollectGarbage(Heap::kNew);
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     String& handle = String::Handle();
     handle ^= Api::UnwrapHandle(str);
     EXPECT(handle.IsOld());
   }
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_EQ(1, isolate->heap()->PeerCount());
   EXPECT_VALID(Dart_SetPeer(str, NULL));
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
@@ skipping 32 matching lines @@
 }
 
 
 // Allocates an object in old space and assigns it a peer.  Allow the
 // peer referent to be garbage collected and check that the count of
 // peer objects is decremented by one.
 TEST_CASE(CollectOneOldSpacePeer) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     Dart_Handle str = Api::NewHandle(isolate, String::New("str", Heap::kOld));
     EXPECT_VALID(str);
     EXPECT(Dart_IsString(str));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* out = &out;
     EXPECT(Dart_GetPeer(str, &out));
     EXPECT(out == NULL);
     int peer = 1234;
     EXPECT_VALID(Dart_SetPeer(str, &peer));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 55 matching lines @@
 }
 
 
 // Allocates two objects in old space and assigns them a peer.  Allows
 // the peer referents to be garbage collected and checks that the
 // count of peer objects is decremented by two.
 TEST_CASE(CollectTwoOldSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   {
-    DARTSCOPE(isolate);
+    DARTSCOPE(Thread::Current());
     Dart_Handle s1 = Api::NewHandle(isolate, String::New("s1", Heap::kOld));
     EXPECT_VALID(s1);
     EXPECT(Dart_IsString(s1));
     EXPECT_EQ(0, isolate->heap()->PeerCount());
     void* o1 = &o1;
     EXPECT(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == NULL);
     int p1 = 1234;
     EXPECT_VALID(Dart_SetPeer(s1, &p1));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
@@ skipping 858 matching lines @@
   // Heartbeat test.
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 }  // namespace dart