Implement safepointing of threads

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 356 matching lines @@
   EXPECT(Dart_IsError(result));
 
   Dart_SetReturnValue(args, Dart_NewInteger(42));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction CurrentStackTraceNativeLookup(
     Dart_Handle name, int argument_count, bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&CurrentStackTraceNative);
 }
 
 
 TEST_CASE(CurrentStacktraceInfo) {
   const char* kScriptChars =
       "inspectStack() native 'CurrentStackTraceNatve';\n"
       "foo(n) => n == 1 ? inspectStack() : foo(n-1);\n"
       "testMain() => foo(50);\n";
 
@@ skipping 120 matching lines @@
   EXPECT(Dart_IsError(result));
   result = Dart_PropagateError(result);
   EXPECT_VALID(result);  // We do not expect to reach here.
   UNREACHABLE();
 }
 
 
 static Dart_NativeFunction PropagateError_native_lookup(
     Dart_Handle name, int argument_count, bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&PropagateErrorNative);
 }
 
 
 TEST_CASE(Dart_PropagateError) {
   const char* kScriptChars =
       "raiseCompileError() {\n"
       "  return missing_semicolon\n"
       "}\n"
       "\n"
@@ skipping 79 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.
   {
-    DARTSCOPE(thread);
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
     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.
   {
-    DARTSCOPE(thread);
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
     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 501 matching lines @@
     Dart_Handle obj16 = Dart_NewExternalUTF16String(
         data16,
         ARRAY_SIZE(data16),
         &peer16,
         ExternalStringCallbackFinalizer);
     EXPECT_VALID(obj16);
 
     Dart_ExitScope();
   }
 
-  EXPECT_EQ(40, peer8);
-  EXPECT_EQ(41, peer16);
-  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);
+  {
+    TransitionNativeToVM transition(thread);
+    EXPECT_EQ(40, peer8);
+    EXPECT_EQ(41, peer16);
+    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) {
   {
     Dart_EnterScope();
     static const uint8_t big_data8[16*MB] = {0, };
     Dart_Handle big8 = Dart_NewExternalLatin1String(
         big_data8,
         ARRAY_SIZE(big_data8),
@@ skipping 14 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(thread);
+      CHECK_API_SCOPE(thread);
+      HANDLESCOPE(thread);
       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());
     }
@@ skipping 13 matching lines @@
         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(thread);
+      CHECK_API_SCOPE(thread);
+      HANDLESCOPE(thread);
       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 454 matching lines @@
   EXPECT_EQ(Dart_TypedData_kByteData, Dart_GetTypeOfTypedData(byte_data));
   Dart_SetReturnValue(args, byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ByteDataNativeResolver(Dart_Handle name,
                                                   int arg_count,
                                                   bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return &ByteDataNativeFunction;
 }
 
 
 TEST_CASE(ByteDataAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
@@ skipping 41 matching lines @@
   EXPECT_EQ(Dart_TypedData_kByteData,
             Dart_GetTypeOfTypedData(external_byte_data));
   Dart_SetReturnValue(args, external_byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ExternalByteDataNativeResolver(
     Dart_Handle name, int arg_count, bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return &ExternalByteDataNativeFunction;
 }
 
 
 TEST_CASE(ExternalByteDataAccess) {
   // TODO(asiva): Once we have getInt16LE and getInt16BE support use the
   // appropriate getter instead of the host endian format used now.
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
@@ skipping 53 matching lines @@
   EXPECT_EQ(Dart_TypedData_kByteData,
             Dart_GetTypeOfTypedData(external_byte_data));
   Dart_SetReturnValue(args, external_byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction OptExternalByteDataNativeResolver(
     Dart_Handle name, int arg_count, bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return &OptExternalByteDataNativeFunction;
 }
 
 
 TEST_CASE(OptimizedExternalByteDataAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
@@ skipping 421 matching lines @@
     uint8_t data[] = { 1, 2, 3, 4 };
     Dart_Handle obj = Dart_NewExternalTypedData(
         Dart_TypedData_kUint8,
         data,
         ARRAY_SIZE(data));
     Dart_NewWeakPersistentHandle(
         obj, &peer, sizeof(data), ExternalTypedDataFinalizer);
     EXPECT_VALID(obj);
     Dart_ExitScope();
   }
-  EXPECT(peer == 0);
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT(peer == 0);
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
-  EXPECT(peer == 42);
+  {
+    TransitionNativeToVM transition(thread);
+    EXPECT(peer == 0);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT(peer == 0);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+    EXPECT(peer == 42);
+  }
 }
 
 
 static void CheckFloat32x4Data(Dart_Handle obj) {
   void* raw_data = NULL;
   intptr_t len;
   Dart_TypedData_Type type;
   EXPECT_VALID(Dart_TypedDataAcquireData(obj, &type, &raw_data, &len));
   EXPECT_EQ(Dart_TypedData_kFloat32x4, type);
   EXPECT_EQ(len, 10);
@@ skipping 31 matching lines @@
   // Dart_NewExternalTypedData.
   Dart_EnterScope();
   {
     Dart_Handle lcl = Dart_NewExternalTypedData(
         Dart_TypedData_kFloat32x4, data, 10);
     Dart_NewWeakPersistentHandle(
         lcl, &peer, sizeof(data), ExternalTypedDataFinalizer);
     CheckFloat32x4Data(lcl);
   }
   Dart_ExitScope();
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
-  EXPECT(peer == 42);
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+    EXPECT(peer == 42);
+  }
 }
 
 
 // Unit test for entering a scope, creating a local handle and exiting
 // the scope.
 UNIT_TEST_CASE(EnterExitScope) {
   TestIsolateScope __test_isolate__;
 
   Thread* thread = Thread::Current();
   EXPECT(thread != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_EnterScope();
   {
     EXPECT(thread->api_top_scope() != NULL);
-    DARTSCOPE(Thread::Current());
+    HANDLESCOPE(thread);
     const String& str1 = String::Handle(String::New("Test String"));
     Dart_Handle ref = Api::NewHandle(thread, str1.raw());
     String& str2 = String::Handle();
     str2 ^= Api::UnwrapHandle(ref);
     EXPECT(str1.Equals(str2));
   }
   Dart_ExitScope();
   EXPECT(scope == thread->api_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();
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = thread->api_top_scope();
   Dart_PersistentHandle handles[2000];
   Dart_EnterScope();
   {
-    DARTSCOPE(Thread::Current());
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
     Dart_Handle ref1 = Api::NewHandle(thread, String::New(kTestString1));
     for (int i = 0; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref1);
     }
     Dart_EnterScope();
     Dart_Handle ref2 = Api::NewHandle(thread, String::New(kTestString2));
     for (int i = 1000; i < 2000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref2);
     }
     for (int i = 500; i < 1500; i++) {
@@ skipping 41 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(Thread::Current());
+  Thread* thread = Thread::Current();
+  CHECK_API_SCOPE(thread);
+  HANDLESCOPE(thread);
 
   // 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));
 
   // Make sure that the value transferred.
   Dart_Handle obj4 = Dart_HandleFromPersistent(obj3);
   EXPECT(Dart_IsBoolean(obj4));
   bool value = false;
   Dart_Handle result = Dart_BooleanValue(obj4, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
 // 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__;
 
-  DARTSCOPE(Thread::Current());
+  Thread* T = Thread::Current();
+  CHECK_API_SCOPE(T);
+  HANDLESCOPE(T);
   Isolate* isolate = T->isolate();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   String& str = String::Handle();
 
   // Start with a known persistent handle.
   Dart_Handle ref1 = Api::NewHandle(T, String::New(kTestString1));
   Dart_PersistentHandle obj = Dart_NewPersistentHandle(ref1);
   EXPECT(state->IsValidPersistentHandle(obj));
@@ skipping 62 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;
     {
-      DARTSCOPE(Thread::Current());
+      CHECK_API_SCOPE(thread);
+      HANDLESCOPE(thread);
       old_ref = Api::NewHandle(thread, 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));
     EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
 
     // Create a weak ref to the old space object.
     weak_old_ref = Dart_NewWeakPersistentHandle(old_ref,
                                                 NULL,
                                                 0,
                                                 WeakPersistentHandleCallback);
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
 
-    // Garbage collect new space.
-    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    {
+      TransitionNativeToVM transition(thread);
+      // Garbage collect new space.
+      GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    }
 
     // Nothing should be invalidated or cleared.
     EXPECT_VALID(new_ref);
     EXPECT(!Dart_IsNull(new_ref));
     EXPECT_VALID(old_ref);
     EXPECT(!Dart_IsNull(old_ref));
 
     EXPECT_VALID(AsHandle(weak_new_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
     EXPECT(Dart_IdentityEquals(new_ref, AsHandle(weak_new_ref)));
 
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
     EXPECT(Dart_IdentityEquals(old_ref, AsHandle(weak_old_ref)));
 
-    // Garbage collect old space.
-    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    {
+      TransitionNativeToVM transition(thread);
+      // Garbage collect old space.
+      Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    }
 
     // Nothing should be invalidated or cleared.
     EXPECT_VALID(new_ref);
     EXPECT(!Dart_IsNull(new_ref));
     EXPECT_VALID(old_ref);
     EXPECT(!Dart_IsNull(old_ref));
 
     EXPECT_VALID(AsHandle(weak_new_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_new_ref)));
     EXPECT(Dart_IdentityEquals(new_ref, AsHandle(weak_new_ref)));
 
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
     EXPECT(Dart_IdentityEquals(old_ref, AsHandle(weak_old_ref)));
 
     // Delete local (strong) references.
     Dart_ExitScope();
   }
 
-  // Garbage collect new space again.
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+  {
+    TransitionNativeToVM transition(thread);
+    // Garbage collect new space again.
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+  }
 
   {
     Dart_EnterScope();
     // Weak ref to new space object should now be cleared.
     EXPECT(weak_new_ref == NULL);
     EXPECT_VALID(AsHandle(weak_old_ref));
     EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
     Dart_ExitScope();
   }
 
-  // Garbage collect old space again.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  {
+    TransitionNativeToVM transition(thread);
+    // Garbage collect old space again.
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
 
   {
     Dart_EnterScope();
     // Weak ref to old space object should now be cleared.
     EXPECT(weak_new_ref == NULL);
     EXPECT(weak_old_ref == NULL);
     Dart_ExitScope();
   }
 
-  // Garbage collect one last time to revisit deleted handles.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  {
+    TransitionNativeToVM transition(thread);
+    // Garbage collect one last time to revisit deleted handles.
+    Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
 }
 
 
 static void WeakPersistentHandlePeerFinalizer(void* isolate_callback_data,
                                               Dart_WeakPersistentHandle handle,
                                               void* peer) {
   *static_cast<int*>(peer) = 42;
 }
 
 
 TEST_CASE(WeakPersistentHandleCallback) {
   Dart_WeakPersistentHandle weak_ref = NULL;
   int peer = 0;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("new string");
     EXPECT_VALID(obj);
     weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     EXPECT_VALID(AsHandle(weak_ref));
     EXPECT(peer == 0);
     Dart_ExitScope();
   }
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT(peer == 0);
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-  EXPECT(peer == 42);
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT(peer == 0);
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    EXPECT(peer == 42);
+  }
 }
 
 
 TEST_CASE(WeakPersistentHandleNoCallback) {
   Dart_WeakPersistentHandle weak_ref = NULL;
   int peer = 0;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("new string");
     EXPECT_VALID(obj);
     weak_ref = Dart_NewWeakPersistentHandle(obj, &peer, 0,
                                             WeakPersistentHandlePeerFinalizer);
     Dart_ExitScope();
   }
   // A finalizer is not invoked on a deleted handle.  Therefore, the
   // peer value should not change after the referent is collected.
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak_ref);
   EXPECT(peer == 0);
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT(peer == 0);
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-  EXPECT(peer == 0);
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT(peer == 0);
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    EXPECT(peer == 0);
+  }
 }
 
 
 UNIT_TEST_CASE(WeakPersistentHandlesCallbackShutdown) {
   TestCase::CreateTestIsolate();
   Dart_EnterScope();
   Dart_Handle ref = Dart_True();
   int peer = 1234;
   Dart_NewWeakPersistentHandle(ref,
                                &peer,
@@ skipping 29 matching lines @@
     Dart_Handle obj = NewString("strongly referenced string");
     EXPECT_VALID(obj);
     strong_ref = Dart_NewPersistentHandle(obj);
     weak2 = Dart_NewWeakPersistentHandle(obj,
                                          NULL,
                                          kWeak2ExternalSize,
                                          NopCallback);
     EXPECT_VALID(AsHandle(strong_ref));
     Dart_ExitScope();
   }
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT(heap->ExternalInWords(Heap::kNew) ==
-         (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
-  // Collect weakly referenced string, and promote strongly referenced string.
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-  EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
-  EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak2ExternalSize / kWordSize);
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT(heap->ExternalInWords(Heap::kNew) ==
+           (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
+    // Collect weakly referenced string, and promote strongly referenced string.
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    EXPECT(heap->ExternalInWords(Heap::kNew) == 0);
+    EXPECT(heap->ExternalInWords(Heap::kOld) == kWeak2ExternalSize / kWordSize);
+  }
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   Dart_DeleteWeakPersistentHandle(isolate, weak2);
   Dart_DeletePersistentHandle(strong_ref);
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
+  }
 }
 
 
 TEST_CASE(WeakPersistentHandleExternalAllocationSizeNewspaceGC) {
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Heap* heap = Isolate::Current()->heap();
   Dart_WeakPersistentHandle weak1 = NULL;
   // Large enough to exceed any new space limit. Not actually allocated.
   const intptr_t kWeak1ExternalSize = 500 * MB;
   {
     Dart_EnterScope();
     Dart_Handle obj = NewString("weakly referenced string");
     EXPECT_VALID(obj);
     // Triggers a scavenge immediately, since kWeak1ExternalSize is above limit.
     weak1 = Dart_NewWeakPersistentHandle(obj,
                                          NULL,
                                          kWeak1ExternalSize,
                                          NopCallback);
     EXPECT_VALID(AsHandle(weak1));
     // ... 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(thread);
+      CHECK_API_SCOPE(thread);
+      HANDLESCOPE(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);
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT(heap->ExternalInWords(Heap::kOld) == 0);
+  }
 }
 
 
 TEST_CASE(WeakPersistentHandleExternalAllocationSizeOldspaceGC) {
   // Check that external allocation in old space can trigger GC.
   Isolate* isolate = Isolate::Current();
   Dart_EnterScope();
   Dart_Handle live = Api::NewHandle(thread, String::New("live", Heap::kOld));
   EXPECT_VALID(live);
   Dart_WeakPersistentHandle weak = NULL;
@@ skipping 46 matching lines @@
         zero, NULL, kWeak2ExternalSize, NopCallback);
     EXPECT_VALID(AsHandle(weak2));
     // Both should be charged to old space.
     EXPECT(heap->ExternalInWords(Heap::kOld) ==
            (kWeak1ExternalSize + kWeak2ExternalSize) / kWordSize);
     Dart_ExitScope();
   }
   Dart_Isolate isolate = reinterpret_cast<Dart_Isolate>(Isolate::Current());
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   Dart_DeleteWeakPersistentHandle(isolate, weak2);
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(0, heap->ExternalInWords(Heap::kOld));
+  }
 }
 
 
 static Dart_WeakPersistentHandle weak1 = NULL;
 static Dart_WeakPersistentHandle weak2 = NULL;
 static Dart_WeakPersistentHandle weak3 = NULL;
 
 
 static void ImplicitReferencesCallback(void* isolate_callback_data,
                                        Dart_WeakPersistentHandle handle,
                                        void* peer) {
   if (handle == weak1) {
     weak1 = NULL;
   } else if (handle == weak2) {
     weak2 = NULL;
   } else if (handle == weak3) {
     weak3 = NULL;
   }
 }
 
 
 TEST_CASE(ImplicitReferencesOldSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_EnterScope();
   {
-    DARTSCOPE(Thread::Current());
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
 
     Dart_Handle local = Api::NewHandle(
         thread, 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 21 matching lines @@
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT_VALID(AsHandle(weak1));
     EXPECT_VALID(AsHandle(weak2));
     EXPECT_VALID(AsHandle(weak3));
     Dart_ExitScope();
   }
 
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+  {
+    TransitionNativeToVM transition(thread);
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+  }
 
   {
     Dart_EnterScope();
     // New space collection should not affect old space objects
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     Dart_ExitScope();
   }
 }
 
 
 TEST_CASE(ImplicitReferencesNewSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
 
   Dart_EnterScope();
   {
-    DARTSCOPE(Thread::Current());
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
 
     Dart_Handle local = Api::NewHandle(
         thread, 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 21 matching lines @@
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT_VALID(AsHandle(weak1));
     EXPECT_VALID(AsHandle(weak2));
     EXPECT_VALID(AsHandle(weak3));
     Dart_ExitScope();
   }
 
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+  }
 
   {
     Dart_EnterScope();
     // Old space collection should not affect old space objects.
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     Dart_ExitScope();
   }
 }
@@ skipping 57 matching lines @@
   EXPECT(Dart_IsError(Dart_SetGcCallbacks(&PrologueCallbackTimes2, NULL)));
   EXPECT(Dart_IsError(Dart_SetGcCallbacks(NULL, &EpilogueCallbackTimes4)));
 }
 
 
 TEST_CASE(SingleGarbageCollectionCallback) {
   // Add a prologue callback.
   EXPECT_VALID(Dart_SetGcCallbacks(&PrologueCallbackTimes2,
                                    &EpilogueCallbackNOP));
 
-  // Garbage collect new space ignoring callbacks.  This should not
-  // invoke the prologue callback.  No status values should change.
-  global_prologue_callback_status = 3;
-  global_epilogue_callback_status = 7;
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-  EXPECT_EQ(3, global_prologue_callback_status);
-  EXPECT_EQ(7, global_epilogue_callback_status);
+  {
+    TransitionNativeToVM transition(thread);
 
-  // Garbage collect new space invoking callbacks.  This should
-  // invoke the prologue callback.  No status values should change.
-  global_prologue_callback_status = 3;
-  global_epilogue_callback_status = 7;
-  GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
-  EXPECT_EQ(6, global_prologue_callback_status);
-  EXPECT_EQ(7, global_epilogue_callback_status);
+    // Garbage collect new space ignoring callbacks.  This should not
+    // invoke the prologue callback.  No status values should change.
+    global_prologue_callback_status = 3;
+    global_epilogue_callback_status = 7;
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    EXPECT_EQ(3, global_prologue_callback_status);
+    EXPECT_EQ(7, global_epilogue_callback_status);
+
+    // Garbage collect new space invoking callbacks.  This should
+    // invoke the prologue callback.  No status values should change.
+    global_prologue_callback_status = 3;
+    global_epilogue_callback_status = 7;
+    GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
+    EXPECT_EQ(6, global_prologue_callback_status);
+    EXPECT_EQ(7, global_epilogue_callback_status);
 
   // Garbage collect old space ignoring callbacks.  This should invoke
   // the prologue callback.  The prologue status value should change.
-  global_prologue_callback_status = 3;
-  global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
-                                             Heap::kIgnoreApiCallbacks,
-                                             Heap::kGCTestCase);
-  EXPECT_EQ(3, global_prologue_callback_status);
-  EXPECT_EQ(7, global_epilogue_callback_status);
+    global_prologue_callback_status = 3;
+    global_epilogue_callback_status = 7;
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
+                                               Heap::kIgnoreApiCallbacks,
+                                               Heap::kGCTestCase);
+    EXPECT_EQ(3, global_prologue_callback_status);
+    EXPECT_EQ(7, global_epilogue_callback_status);
 
-  // Garbage collect old space.  This should invoke the prologue
-  // callback.  The prologue status value should change.
-  global_prologue_callback_status = 3;
-  global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(6, global_prologue_callback_status);
-  EXPECT_EQ(7, global_epilogue_callback_status);
+    // Garbage collect old space.  This should invoke the prologue
+    // callback.  The prologue status value should change.
+    global_prologue_callback_status = 3;
+    global_epilogue_callback_status = 7;
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(6, global_prologue_callback_status);
+    EXPECT_EQ(7, global_epilogue_callback_status);
 
-  // Garbage collect old space again.  Callbacks are persistent so the
-  // prologue status value should change again.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(12, global_prologue_callback_status);
-  EXPECT_EQ(7, global_epilogue_callback_status);
+    // Garbage collect old space again.  Callbacks are persistent so the
+    // prologue status value should change again.
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(12, global_prologue_callback_status);
+    EXPECT_EQ(7, global_epilogue_callback_status);
+  }
 
   // Add an epilogue callback.
   EXPECT_VALID(Dart_SetGcCallbacks(NULL, NULL));
   EXPECT_VALID(Dart_SetGcCallbacks(&PrologueCallbackTimes2,
                                    &EpilogueCallbackTimes4));
 
-  // Garbage collect new space.  This should not invoke the prologue
-  // or the epilogue callback.  No status values should change.
-  global_prologue_callback_status = 3;
-  global_epilogue_callback_status = 7;
-  GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
-  EXPECT_EQ(3, global_prologue_callback_status);
-  EXPECT_EQ(7, global_epilogue_callback_status);
+  {
+    TransitionNativeToVM transition(thread);
+    // Garbage collect new space.  This should not invoke the prologue
+    // or the epilogue callback.  No status values should change.
+    global_prologue_callback_status = 3;
+    global_epilogue_callback_status = 7;
+    GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
+    EXPECT_EQ(3, global_prologue_callback_status);
+    EXPECT_EQ(7, global_epilogue_callback_status);
 
-  // Garbage collect new space.  This should invoke the prologue and
-  // the epilogue callback.  The prologue and epilogue status values
-  // should change.
-  GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
-  EXPECT_EQ(6, global_prologue_callback_status);
-  EXPECT_EQ(28, global_epilogue_callback_status);
+    // Garbage collect new space.  This should invoke the prologue and
+    // the epilogue callback.  The prologue and epilogue status values
+    // should change.
+    GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
+    EXPECT_EQ(6, global_prologue_callback_status);
+    EXPECT_EQ(28, global_epilogue_callback_status);
 
-  // Garbage collect old space.  This should invoke the prologue and
-  // the epilogue callbacks.  The prologue and epilogue status values
-  // should change.
-  global_prologue_callback_status = 3;
-  global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(6, global_prologue_callback_status);
-  EXPECT_EQ(28, global_epilogue_callback_status);
+    // Garbage collect old space.  This should invoke the prologue and
+    // the epilogue callbacks.  The prologue and epilogue status values
+    // should change.
+    global_prologue_callback_status = 3;
+    global_epilogue_callback_status = 7;
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(6, global_prologue_callback_status);
+    EXPECT_EQ(28, global_epilogue_callback_status);
 
-  // Garbage collect old space again without invoking callbacks.
-  // Nothing should change.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
-                                             Heap::kIgnoreApiCallbacks,
-                                             Heap::kGCTestCase);
-  EXPECT_EQ(6, global_prologue_callback_status);
-  EXPECT_EQ(28, global_epilogue_callback_status);
+    // Garbage collect old space again without invoking callbacks.
+    // Nothing should change.
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
+                                               Heap::kIgnoreApiCallbacks,
+                                               Heap::kGCTestCase);
+    EXPECT_EQ(6, global_prologue_callback_status);
+    EXPECT_EQ(28, global_epilogue_callback_status);
 
-  // Garbage collect old space again.  Callbacks are persistent so the
-  // prologue and epilogue status values should change again.
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(12, global_prologue_callback_status);
-  EXPECT_EQ(112, global_epilogue_callback_status);
+    // Garbage collect old space again.  Callbacks are persistent so the
+    // prologue and epilogue status values should change again.
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(12, global_prologue_callback_status);
+    EXPECT_EQ(112, global_epilogue_callback_status);
+  }
 
   // Remove the prologue and epilogue callbacks
   EXPECT_VALID(Dart_SetGcCallbacks(NULL, NULL));
 
-  // Garbage collect old space.  No callbacks should be invoked.  No
-  // status values should change.
-  global_prologue_callback_status = 3;
-  global_epilogue_callback_status = 7;
-  Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(3, global_prologue_callback_status);
-  EXPECT_EQ(7, global_epilogue_callback_status);
+  {
+    TransitionNativeToVM transition(thread);
+    // Garbage collect old space.  No callbacks should be invoked.  No
+    // status values should change.
+    global_prologue_callback_status = 3;
+    global_epilogue_callback_status = 7;
+    Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(3, global_prologue_callback_status);
+    EXPECT_EQ(7, global_epilogue_callback_status);
+  }
 }
 
 
 // Unit test for creating multiple scopes and local handles within them.
 // Ensure that the local handles get all cleaned out when exiting the
 // scope.
 UNIT_TEST_CASE(LocalHandles) {
   TestCase::CreateTestIsolate();
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
@@ skipping 790 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(Thread::Current());
+  CHECK_API_SCOPE(thread);
+  HANDLESCOPE(thread);
   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(Thread::Current());
+  CHECK_API_SCOPE(thread);
+  HANDLESCOPE(thread);
   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(Thread::Current());
+  CHECK_API_SCOPE(thread);
+  HANDLESCOPE(thread);
 
   // 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(Thread::Current());
+  CHECK_API_SCOPE(thread);
+  HANDLESCOPE(thread);
 
   // 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 688 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(Thread::Current());
+  CHECK_API_SCOPE(thread);
+  HANDLESCOPE(thread);
 
   // 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 32 matching lines @@
   Dart_EnterScope();
   Dart_ThrowException(NewString("Hello from ExceptionNative!"));
   UNREACHABLE();
 }
 
 
 static Dart_NativeFunction native_lookup(Dart_Handle name,
                                          int argument_count,
                                          bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&ExceptionNative);
 }
 
 
 TEST_CASE(ThrowException) {
   const char* kScriptChars =
       "int test() native \"ThrowException_native\";";
   Dart_Handle result;
   intptr_t size = thread->ZoneSizeInBytes();
   Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
@@ skipping 225 matching lines @@
   int count = Dart_GetNativeArgumentCount(args);
   Dart_SetReturnValue(args, Dart_NewInteger(count));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction gnac_lookup(Dart_Handle name,
                                        int argument_count,
                                        bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&NativeArgumentCounter);
 }
 
 
 TEST_CASE(GetNativeArgumentCount) {
   const char* kScriptChars =
       "class MyObject {"
       "  int method1(int i, int j) native 'Name_Does_Not_Matter';"
       "}"
       "testMain() {"
@@ skipping 2472 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(Thread::Current());
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
     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());
     out = &out;
     EXPECT_VALID(Dart_GetPeer(str, &out));
     EXPECT(out == reinterpret_cast<void*>(&peer));
-    isolate->heap()->CollectGarbage(Heap::kNew);
-    EXPECT_EQ(1, isolate->heap()->PeerCount());
+    {
+      TransitionNativeToVM transition(thread);
+      isolate->heap()->CollectGarbage(Heap::kNew);
+      EXPECT_EQ(1, isolate->heap()->PeerCount());
+    }
     out = &out;
     EXPECT_VALID(Dart_GetPeer(str, &out));
     EXPECT(out == reinterpret_cast<void*>(&peer));
   }
   Dart_ExitScope();
-  isolate->heap()->CollectGarbage(Heap::kNew);
-  EXPECT_EQ(0, isolate->heap()->PeerCount());
+  {
+    TransitionNativeToVM transition(thread);
+    isolate->heap()->CollectGarbage(Heap::kNew);
+    EXPECT_EQ(0, isolate->heap()->PeerCount());
+  }
 }
 
 
 // Allocates two objects in new space and assigns them peers.  Removes
 // the peers and checks that the count of peer objects is decremented
 // by two.
 TEST_CASE(TwoNewSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle s1 = NewString("s1");
   EXPECT_VALID(s1);
@@ skipping 30 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(Thread::Current());
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
     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());
     EXPECT_VALID(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == reinterpret_cast<void*>(&p1));
     Dart_Handle s2 = NewString("s2");
     EXPECT_VALID(s2);
     EXPECT(Dart_IsString(s2));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
     void* o2 = &o2;
     EXPECT(Dart_GetPeer(s2, &o2));
     EXPECT(o2 == NULL);
     int p2 = 5678;
     EXPECT_VALID(Dart_SetPeer(s2, &p2));
     EXPECT_EQ(2, isolate->heap()->PeerCount());
     EXPECT_VALID(Dart_GetPeer(s2, &o2));
     EXPECT(o2 == reinterpret_cast<void*>(&p2));
   }
   Dart_ExitScope();
-  isolate->heap()->CollectGarbage(Heap::kNew);
-  EXPECT_EQ(0, isolate->heap()->PeerCount());
+  {
+    TransitionNativeToVM transition(thread);
+    isolate->heap()->CollectGarbage(Heap::kNew);
+    EXPECT_EQ(0, isolate->heap()->PeerCount());
+  }
 }
 
 
 // Allocates several objects in new space.  Performs successive
 // garbage collections and checks that the peer count is stable.
 TEST_CASE(CopyNewSpacePeers) {
   const int kPeerCount = 10;
   Isolate* isolate = Isolate::Current();
   Dart_Handle s[kPeerCount];
   for (int i = 0; i < kPeerCount; ++i) {
     s[i] = NewString("a string");
     EXPECT_VALID(s[i]);
     EXPECT(Dart_IsString(s[i]));
     void* o = &o;
     EXPECT_VALID(Dart_GetPeer(s[i], &o));
     EXPECT(o == NULL);
   }
   EXPECT_EQ(0, isolate->heap()->PeerCount());
   int p[kPeerCount];
   for (int i = 0; i < kPeerCount; ++i) {
     EXPECT_VALID(Dart_SetPeer(s[i], &p[i]));
     EXPECT_EQ(i + 1, isolate->heap()->PeerCount());
     void* o = &o;
     EXPECT_VALID(Dart_GetPeer(s[i], &o));
     EXPECT(o == reinterpret_cast<void*>(&p[i]));
   }
   EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
-  isolate->heap()->CollectGarbage(Heap::kNew);
-  EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
-  isolate->heap()->CollectGarbage(Heap::kNew);
-  EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
+  {
+    TransitionNativeToVM transition(thread);
+    isolate->heap()->CollectGarbage(Heap::kNew);
+    EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
+    isolate->heap()->CollectGarbage(Heap::kNew);
+    EXPECT_EQ(kPeerCount, isolate->heap()->PeerCount());
+  }
 }
 
 
 // Allocates an object in new space and assigns it a peer.  Promotes
 // the peer to old space.  Removes the peer and check that the count
 // of peer objects is decremented by one.
 TEST_CASE(OnePromotedPeer) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle str = NewString("a string");
   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));
   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(Thread::Current());
+    TransitionNativeToVM transition(thread);
+    isolate->heap()->CollectGarbage(Heap::kNew);
+    isolate->heap()->CollectGarbage(Heap::kNew);
+  }
+  {
+    CHECK_API_SCOPE(thread);
+    HANDLESCOPE(thread);
     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 13 matching lines @@
   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());
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
-  isolate->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(1, isolate->heap()->PeerCount());
+  {
+    TransitionNativeToVM transition(thread);
+    isolate->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(1, isolate->heap()->PeerCount());
+  }
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == reinterpret_cast<void*>(&peer));
   EXPECT_VALID(Dart_SetPeer(str, NULL));
   out = &out;
   EXPECT_VALID(Dart_GetPeer(str, &out));
   EXPECT(out == NULL);
   EXPECT_EQ(0, isolate->heap()->PeerCount());
 }
 
 
 // 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(Thread::Current());
+    Thread* T = Thread::Current();
+    CHECK_API_SCOPE(T);
+    HANDLESCOPE(T);
     Dart_Handle str = Api::NewHandle(T, 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());
     out = &out;
     EXPECT_VALID(Dart_GetPeer(str, &out));
     EXPECT(out == reinterpret_cast<void*>(&peer));
-    isolate->heap()->CollectGarbage(Heap::kOld);
-    EXPECT_EQ(1, isolate->heap()->PeerCount());
+    {
+      TransitionNativeToVM transition(thread);
+      isolate->heap()->CollectGarbage(Heap::kOld);
+      EXPECT_EQ(1, isolate->heap()->PeerCount());
+    }
     EXPECT_VALID(Dart_GetPeer(str, &out));
     EXPECT(out == reinterpret_cast<void*>(&peer));
   }
   Dart_ExitScope();
-  isolate->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(0, isolate->heap()->PeerCount());
+  {
+    TransitionNativeToVM transition(thread);
+    isolate->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(0, isolate->heap()->PeerCount());
+  }
 }
 
 
 // Allocates two objects in old space and assigns them peers.  Removes
 // the peers and checks that the count of peer objects is decremented
 // by two.
 TEST_CASE(TwoOldSpacePeers) {
   Isolate* isolate = Isolate::Current();
   Dart_Handle s1 = Api::NewHandle(thread, String::New("s1", Heap::kOld));
   EXPECT_VALID(s1);
@@ skipping 34 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(Thread::Current());
+    Thread* T = Thread::Current();
+    CHECK_API_SCOPE(T);
+    HANDLESCOPE(T);
     Dart_Handle s1 = Api::NewHandle(T, 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());
     o1 = &o1;
     EXPECT_VALID(Dart_GetPeer(s1, &o1));
     EXPECT(o1 == reinterpret_cast<void*>(&p1));
     Dart_Handle s2 = Api::NewHandle(T, String::New("s2", Heap::kOld));
     EXPECT_VALID(s2);
     EXPECT(Dart_IsString(s2));
     EXPECT_EQ(1, isolate->heap()->PeerCount());
     void* o2 = &o2;
     EXPECT(Dart_GetPeer(s2, &o2));
     EXPECT(o2 == NULL);
     int p2 = 5678;
     EXPECT_VALID(Dart_SetPeer(s2, &p2));
     EXPECT_EQ(2, isolate->heap()->PeerCount());
     o2 = &o2;
     EXPECT_VALID(Dart_GetPeer(s2, &o2));
     EXPECT(o2 == reinterpret_cast<void*>(&p2));
   }
   Dart_ExitScope();
-  isolate->heap()->CollectGarbage(Heap::kOld);
-  EXPECT_EQ(0, isolate->heap()->PeerCount());
+  {
+    TransitionNativeToVM transition(thread);
+    isolate->heap()->CollectGarbage(Heap::kOld);
+    EXPECT_EQ(0, isolate->heap()->PeerCount());
+  }
 }
 
 
 // Test API call to make strings external.
 static void MakeExternalCback(void* peer) {
   *static_cast<int*>(peer) *= 2;
 }
 
 
 TEST_CASE(MakeExternalString) {
@@ skipping 186 matching lines @@
     EXPECT(Dart_IdentityEquals(str, symbol_str));
     for (intptr_t i = 0; i < length; i++) {
       EXPECT_EQ(symbol_ascii[i], ext_symbol_ascii[i]);
     }
 
     Dart_ExitScope();
   }
   EXPECT_EQ(40, peer8);
   EXPECT_EQ(41, peer16);
   EXPECT_EQ(42, canonical_str_peer);
-  Isolate::Current()->heap()->CollectAllGarbage();
+  {
+    TransitionNativeToVM transition(thread);
+    Isolate::Current()->heap()->CollectAllGarbage();
+  }
   EXPECT_EQ(80, peer8);
   EXPECT_EQ(82, peer16);
   EXPECT_EQ(42, canonical_str_peer);  // "*" Symbol is not removed on GC.
 }
 
 
 TEST_CASE(ExternalizeConstantStrings) {
   const char* kScriptChars =
       "String testMain() {\n"
       "  return 'constant string';\n"
@@ skipping 91 matching lines @@
                               &ExternalStringDeoptimize_Finalize);
   EXPECT_VALID(result);
   EXPECT(Dart_IsExternalString(result));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ExternalStringDeoptimize_native_lookup(
     Dart_Handle name, int argument_count, bool* auto_setup_scope) {
   ASSERT(auto_setup_scope != NULL);
-  *auto_setup_scope = false;
+  *auto_setup_scope = true;
   return reinterpret_cast<Dart_NativeFunction>(&A_change_str_native);
 }
 
 
 // Do not use guarding mechanism on externalizable classes, since their class
 // can change on the fly,
 TEST_CASE(GuardExternalizedString) {
   const char* kScriptChars =
       "main() {\n"
       "  var a = new A('hello');\n"
@@ skipping 943 matching lines @@
   EXPECT_SUBSTRING("\"cat\":\"Compiler\"", buffer);
   EXPECT_SUBSTRING("\"name\":\"CompileFunction\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_main\"", buffer);
 
   // Heartbeat test for new events.
   EXPECT_SUBSTRING("\"name\":\"TestVMDuration2\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_bar\"", buffer);
 }
 
 }  // namespace dart