Move ApiLocalScope out of class ApiState into class Thread so that the API local handles and zone e…

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 379 matching lines @@
   Dart_Handle result = Dart_Invoke(lib, NewString("testMain"), 0, NULL);
   EXPECT_VALID(result);
   EXPECT(Dart_IsInteger(result));
   int64_t value = 0;
   EXPECT_VALID(Dart_IntegerToInt64(result, &value));
   EXPECT_EQ(42, value);
 }
 
 
 TEST_CASE(ErrorHandleTypes) {
-  Isolate* isolate = Isolate::Current();
   const String& compile_message = String::Handle(String::New("CompileError"));
   const String& fatal_message = String::Handle(String::New("FatalError"));
 
   Dart_Handle not_error = NewString("NotError");
   Dart_Handle api_error = Api::NewError("Api%s", "Error");
   Dart_Handle exception_error =
       Dart_NewUnhandledExceptionError(NewString("ExceptionError"));
   Dart_Handle compile_error =
-      Api::NewHandle(isolate, LanguageError::New(compile_message));
+      Api::NewHandle(thread, LanguageError::New(compile_message));
   Dart_Handle fatal_error =
-      Api::NewHandle(isolate, UnwindError::New(fatal_message));
+      Api::NewHandle(thread, UnwindError::New(fatal_message));
 
   EXPECT_VALID(not_error);
   EXPECT(Dart_IsError(api_error));
   EXPECT(Dart_IsError(exception_error));
   EXPECT(Dart_IsError(compile_error));
   EXPECT(Dart_IsError(fatal_error));
 
   EXPECT(!Dart_IsApiError(not_error));
   EXPECT(Dart_IsApiError(api_error));
   EXPECT(!Dart_IsApiError(exception_error));
@@ skipping 21 matching lines @@
   EXPECT_STREQ("", Dart_GetError(not_error));
   EXPECT_STREQ("ApiError", Dart_GetError(api_error));
   EXPECT_SUBSTRING("Unhandled exception:\nExceptionError",
                    Dart_GetError(exception_error));
   EXPECT_STREQ("CompileError", Dart_GetError(compile_error));
   EXPECT_STREQ("FatalError", Dart_GetError(fatal_error));
 }
 
 
 TEST_CASE(UnhandleExceptionError) {
-  Isolate* isolate = Isolate::Current();
   const char* exception_cstr = "";
 
   // Test with an API Error.
   const char* kApiError = "Api Error Exception Test.";
   Dart_Handle api_error = Api::NewHandle(
-      isolate,
+      thread,
       ApiError::New(String::Handle(String::New(kApiError))));
   Dart_Handle exception_error = Dart_NewUnhandledExceptionError(api_error);
   EXPECT(!Dart_IsApiError(exception_error));
   EXPECT(Dart_IsUnhandledExceptionError(exception_error));
   EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
   EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                     &exception_cstr));
   EXPECT_STREQ(kApiError, exception_cstr);
 
   // Test with a Compilation Error.
   const char* kCompileError = "CompileError Exception Test.";
   const String& compile_message =
       String::Handle(String::New(kCompileError));
   Dart_Handle compile_error =
-      Api::NewHandle(isolate, LanguageError::New(compile_message));
+      Api::NewHandle(thread, LanguageError::New(compile_message));
   exception_error = Dart_NewUnhandledExceptionError(compile_error);
   EXPECT(!Dart_IsApiError(exception_error));
   EXPECT(Dart_IsUnhandledExceptionError(exception_error));
   EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
   EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                     &exception_cstr));
   EXPECT_STREQ(kCompileError, exception_cstr);
 
   // Test with a Fatal Error.
   const String& fatal_message =
       String::Handle(String::New("FatalError Exception Test."));
   Dart_Handle fatal_error =
-      Api::NewHandle(isolate, UnwindError::New(fatal_message));
+      Api::NewHandle(thread, UnwindError::New(fatal_message));
   exception_error = Dart_NewUnhandledExceptionError(fatal_error);
   EXPECT(Dart_IsError(exception_error));
   EXPECT(!Dart_IsUnhandledExceptionError(exception_error));
 
   // Test with a Regular object.
   const char* kRegularString = "Regular String Exception Test.";
-  Dart_Handle obj = Api::NewHandle(isolate, String::New(kRegularString));
+  Dart_Handle obj = Api::NewHandle(thread, String::New(kRegularString));
   exception_error = Dart_NewUnhandledExceptionError(obj);
   EXPECT(!Dart_IsApiError(exception_error));
   EXPECT(Dart_IsUnhandledExceptionError(exception_error));
   EXPECT(Dart_IsString(Dart_ErrorGetException(exception_error)));
   EXPECT_VALID(Dart_StringToCString(Dart_ErrorGetException(exception_error),
                                     &exception_cstr));
   EXPECT_STREQ(kRegularString, exception_cstr);
 }
 
 
@@ skipping 105 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::Current());
+    DARTSCOPE(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::Current());
+    DARTSCOPE(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 543 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::Current());
+      DARTSCOPE(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::Current());
+      DARTSCOPE(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 1098 matching lines @@
   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__;
 
-  Isolate* isolate = Isolate::Current();
-  EXPECT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  EXPECT(state != NULL);
-  ApiLocalScope* scope = state->top_scope();
+  Thread* thread = Thread::Current();
+  EXPECT(thread != NULL);
+  ApiLocalScope* scope = thread->api_top_scope();
   Dart_EnterScope();
   {
-    EXPECT(state->top_scope() != NULL);
+    EXPECT(thread->api_top_scope() != NULL);
     DARTSCOPE(Thread::Current());
     const String& str1 = String::Handle(String::New("Test String"));
-    Dart_Handle ref = Api::NewHandle(isolate, str1.raw());
+    Dart_Handle ref = Api::NewHandle(thread, str1.raw());
     String& str2 = String::Handle();
     str2 ^= Api::UnwrapHandle(ref);
     EXPECT(str1.Equals(str2));
   }
   Dart_ExitScope();
-  EXPECT(scope == state->top_scope());
+  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 = state->top_scope();
+  ApiLocalScope* scope = thread->api_top_scope();
   Dart_PersistentHandle handles[2000];
   Dart_EnterScope();
   {
     DARTSCOPE(Thread::Current());
-    Dart_Handle ref1 = Api::NewHandle(isolate, String::New(kTestString1));
+    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(isolate, String::New(kTestString2));
+    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++) {
       Dart_DeletePersistentHandle(handles[i]);
     }
     for (int i = 500; i < 1000; i++) {
       handles[i] = Dart_NewPersistentHandle(ref2);
     }
     for (int i = 1000; i < 1500; i++) {
@@ skipping 20 matching lines @@
       String& str = String::Handle();
       str ^= PersistentHandle::Cast(handles[i])->raw();
       EXPECT(str.Equals(kTestString1));
     }
     for (int i = 1500; i < 2000; i++) {
       String& str = String::Handle();
       str ^= PersistentHandle::Cast(handles[i])->raw();
       EXPECT(str.Equals(kTestString2));
     }
   }
-  EXPECT(scope == state->top_scope());
+  EXPECT(scope == thread->api_top_scope());
   EXPECT_EQ(2001, state->CountPersistentHandles());
   Dart_ShutdownIsolate();
 }
 
 
 // Test that we are able to create a persistent handle from a
 // persistent handle.
 UNIT_TEST_CASE(NewPersistentHandle_FromPersistentHandle) {
   TestIsolateScope __test_isolate__;
 
@@ skipping 21 matching lines @@
   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__;
 
-  Isolate* isolate = Isolate::Current();
+  DARTSCOPE(Thread::Current());
+  Isolate* isolate = T->isolate();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
-  DARTSCOPE(Thread::Current());
   String& str = String::Handle();
 
   // Start with a known persistent handle.
-  Dart_Handle ref1 = Api::NewHandle(isolate, String::New(kTestString1));
+  Dart_Handle ref1 = Api::NewHandle(T, 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.
-  Dart_Handle ref2 = Api::NewHandle(isolate, String::New(kTestString2));
+  Dart_Handle ref2 = Api::NewHandle(T, String::New(kTestString2));
   Dart_SetPersistentHandle(obj, ref2);
   str ^= PersistentHandle::Cast(obj)->raw();
   EXPECT(str.Equals(kTestString2));
 
   // Now assign Null to the persistent handle and check.
   Dart_SetPersistentHandle(obj, Dart_Null());
   EXPECT(Dart_IsNull(obj));
 }
 
 
@@ skipping 47 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(Thread::Current());
-      old_ref = Api::NewHandle(isolate, String::New("old string", Heap::kOld));
+      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)));
@@ skipping 224 matching lines @@
   Dart_DeleteWeakPersistentHandle(isolate, weak1);
   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(isolate, String::New("live", Heap::kOld));
+  Dart_Handle live = Api::NewHandle(thread, String::New("live", Heap::kOld));
   EXPECT_VALID(live);
   Dart_WeakPersistentHandle weak = NULL;
   EXPECT_EQ(0, isolate->heap()->ExternalInWords(Heap::kOld));
   const intptr_t kSmallExternalSize = 1 * KB;
   {
     Dart_EnterScope();
-    Dart_Handle dead = Api::NewHandle(isolate, String::New("dead", Heap::kOld));
+    Dart_Handle dead = Api::NewHandle(thread, String::New("dead", Heap::kOld));
     EXPECT_VALID(dead);
     weak = Dart_NewWeakPersistentHandle(dead,
                                         NULL,
                                         kSmallExternalSize,
                                         NopCallback);
     EXPECT_VALID(AsHandle(weak));
     Dart_ExitScope();
   }
   EXPECT_EQ(kSmallExternalSize,
             isolate->heap()->ExternalInWords(Heap::kOld) * kWordSize);
@@ skipping 60 matching lines @@
   }
 }
 
 
 TEST_CASE(ImplicitReferencesOldSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
   Dart_EnterScope();
   {
-    Isolate* isolate = Isolate::Current();
     DARTSCOPE(Thread::Current());
 
     Dart_Handle local = Api::NewHandle(
-        isolate, String::New("strongly reachable", Heap::kOld));
+        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));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
     weak1 = Dart_NewWeakPersistentHandle(
-        Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kOld)),
+        Api::NewHandle(thread, String::New("weakly reachable 1", Heap::kOld)),
         NULL, 0, ImplicitReferencesCallback);
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT_VALID(AsHandle(weak1));
 
     weak2 = Dart_NewWeakPersistentHandle(
-        Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kOld)),
+        Api::NewHandle(thread, String::New("weakly reachable 2", Heap::kOld)),
         NULL, 0, ImplicitReferencesCallback);
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT_VALID(AsHandle(weak2));
 
     weak3 = Dart_NewWeakPersistentHandle(
-        Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kOld)),
+        Api::NewHandle(thread, String::New("weakly reachable 3", Heap::kOld)),
         NULL, 0, ImplicitReferencesCallback);
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     EXPECT_VALID(AsHandle(weak3));
   }
   Dart_ExitScope();
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT_VALID(AsHandle(weak1));
@@ skipping 16 matching lines @@
 }
 
 
 TEST_CASE(ImplicitReferencesNewSpace) {
   Dart_PersistentHandle strong = NULL;
   Dart_WeakPersistentHandle strong_weak = NULL;
 
 
   Dart_EnterScope();
   {
-    Isolate* isolate = Isolate::Current();
     DARTSCOPE(Thread::Current());
 
     Dart_Handle local = Api::NewHandle(
-        isolate, String::New("strongly reachable", Heap::kOld));
+        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));
     EXPECT(Dart_IdentityEquals(AsHandle(strong), AsHandle(strong_weak)))
 
     weak1 = Dart_NewWeakPersistentHandle(
-        Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kNew)),
+        Api::NewHandle(thread, String::New("weakly reachable 1", Heap::kNew)),
         NULL, 0, ImplicitReferencesCallback);
     EXPECT(!Dart_IsNull(AsHandle(weak1)));
     EXPECT_VALID(AsHandle(weak1));
 
     weak2 = Dart_NewWeakPersistentHandle(
-        Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kNew)),
+        Api::NewHandle(thread, String::New("weakly reachable 2", Heap::kNew)),
         NULL, 0, ImplicitReferencesCallback);
     EXPECT(!Dart_IsNull(AsHandle(weak2)));
     EXPECT_VALID(AsHandle(weak2));
 
     weak3 = Dart_NewWeakPersistentHandle(
-        Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kNew)),
+        Api::NewHandle(thread, String::New("weakly reachable 3", Heap::kNew)),
         NULL, 0, ImplicitReferencesCallback);
     EXPECT(!Dart_IsNull(AsHandle(weak3)));
     EXPECT_VALID(AsHandle(weak3));
   }
   Dart_ExitScope();
 
   {
     Dart_EnterScope();
     EXPECT_VALID(AsHandle(strong_weak));
     EXPECT_VALID(AsHandle(weak1));
@@ skipping 177 matching lines @@
 
 
 // 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();
   EXPECT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  EXPECT(state != NULL);
-  ApiLocalScope* scope = state->top_scope();
+  ApiLocalScope* scope = thread->api_top_scope();
   Dart_Handle handles[300];
   {
     StackZone zone(thread);
     HANDLESCOPE(thread);
     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));
+      handles[i] = Api::NewHandle(thread, Smi::New(i));
     }
-    EXPECT_EQ(100, state->CountLocalHandles());
+    EXPECT_EQ(100, thread->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++) {
-        handles[i] = Api::NewHandle(isolate, Smi::New(i));
+        handles[i] = Api::NewHandle(thread, Smi::New(i));
       }
-      EXPECT_EQ(200, state->CountLocalHandles());
+      EXPECT_EQ(200, thread->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++) {
-          handles[i] = Api::NewHandle(isolate, Smi::New(i));
+          handles[i] = Api::NewHandle(thread, Smi::New(i));
         }
-        EXPECT_EQ(300, state->CountLocalHandles());
+        EXPECT_EQ(300, thread->CountLocalHandles());
         for (int i = 200; i < 300; i++) {
           val ^= Api::UnwrapHandle(handles[i]);
           EXPECT_EQ(i, val.Value());
         }
-        EXPECT_EQ(300, state->CountLocalHandles());
+        EXPECT_EQ(300, thread->CountLocalHandles());
         VERIFY_ON_TRANSITION;
         Dart_ExitScope();
       }
-      EXPECT_EQ(200, state->CountLocalHandles());
+      EXPECT_EQ(200, thread->CountLocalHandles());
       Dart_ExitScope();
     }
-    EXPECT_EQ(100, state->CountLocalHandles());
+    EXPECT_EQ(100, thread->CountLocalHandles());
     Dart_ExitScope();
   }
-  EXPECT_EQ(0, state->CountLocalHandles());
-  EXPECT(scope == state->top_scope());
+  EXPECT_EQ(0, thread->CountLocalHandles());
+  EXPECT(scope == thread->api_top_scope());
   Dart_ShutdownIsolate();
 }
 
 
 // Unit test for creating multiple scopes and allocating objects in the
 // zone for the scope. Ensure that the memory is freed when the scope
 // exits.
 UNIT_TEST_CASE(LocalZoneMemory) {
   TestCase::CreateTestIsolate();
-  Isolate* isolate = Isolate::Current();
-  EXPECT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  EXPECT(state != NULL);
-  ApiLocalScope* scope = state->top_scope();
+  Thread* thread = Thread::Current();
+  EXPECT(thread != NULL);
+  ApiLocalScope* scope = thread->api_top_scope();
   {
     // Start a new scope and allocate some memory.
     Dart_EnterScope();
     for (int i = 0; i < 100; i++) {
       Dart_ScopeAllocate(16);
     }
-    EXPECT_EQ(1600, state->ZoneSizeInBytes());
+    EXPECT_EQ(1600, thread->ZoneSizeInBytes());
     // Start another scope and allocate some more memory.
     {
       Dart_EnterScope();
       for (int i = 0; i < 100; i++) {
         Dart_ScopeAllocate(16);
       }
-      EXPECT_EQ(3200, state->ZoneSizeInBytes());
+      EXPECT_EQ(3200, thread->ZoneSizeInBytes());
       {
         // Start another scope and allocate some more memory.
         {
           Dart_EnterScope();
           for (int i = 0; i < 200; i++) {
             Dart_ScopeAllocate(16);
           }
-          EXPECT_EQ(6400, state->ZoneSizeInBytes());
+          EXPECT_EQ(6400, thread->ZoneSizeInBytes());
           Dart_ExitScope();
         }
       }
-      EXPECT_EQ(3200, state->ZoneSizeInBytes());
+      EXPECT_EQ(3200, thread->ZoneSizeInBytes());
       Dart_ExitScope();
     }
-    EXPECT_EQ(1600, state->ZoneSizeInBytes());
+    EXPECT_EQ(1600, thread->ZoneSizeInBytes());
     Dart_ExitScope();
   }
-  EXPECT_EQ(0, state->ZoneSizeInBytes());
-  EXPECT(scope == state->top_scope());
+  EXPECT_EQ(0, thread->ZoneSizeInBytes());
+  EXPECT(scope == thread->api_top_scope());
   Dart_ShutdownIsolate();
 }
 
 
 UNIT_TEST_CASE(Isolates) {
   // This test currently assumes that the Dart_Isolate type is an opaque
   // representation of Isolate*.
   Dart_Isolate iso_1 = TestCase::CreateTestIsolate();
   EXPECT_EQ(iso_1, Api::CastIsolate(Isolate::Current()));
   Dart_Isolate isolate = Dart_CurrentIsolate();
@@ skipping 1508 matching lines @@
   EXPECT_VALID(list_obj);
   EXPECT(Dart_IsList(list_obj));
 }
 
 
 static Dart_Handle PrivateLibName(Dart_Handle lib, const char* str) {
   EXPECT(Dart_IsLibrary(lib));
   Thread* thread = Thread::Current();
   const Library& library_obj = Api::UnwrapLibraryHandle(thread->zone(), lib);
   const String& name = String::Handle(String::New(str));
-  return Api::NewHandle(thread->isolate(), library_obj.PrivateName(name));
+  return Api::NewHandle(thread, library_obj.PrivateName(name));
 }
 
 
 TEST_CASE(Invoke) {
   const char* kScriptChars =
       "class BaseMethods {\n"
       "  inheritedMethod(arg) => 'inherited $arg';\n"
       "  static nonInheritedMethod(arg) => 'noninherited $arg';\n"
       "}\n"
       "\n"
@@ skipping 390 matching lines @@
   ASSERT(auto_setup_scope != NULL);
   *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&ExceptionNative);
 }
 
 
 TEST_CASE(ThrowException) {
   const char* kScriptChars =
       "int test() native \"ThrowException_native\";";
   Dart_Handle result;
-  Isolate* isolate = Isolate::Current();
-  EXPECT(isolate != NULL);
-  ApiState* state = isolate->api_state();
-  EXPECT(state != NULL);
-  intptr_t size = state->ZoneSizeInBytes();
+  intptr_t size = thread->ZoneSizeInBytes();
   Dart_EnterScope();  // Start a Dart API scope for invoking API functions.
 
   // Load up a test script which extends the native wrapper class.
   Dart_Handle lib = TestCase::LoadTestScript(
       kScriptChars,
       reinterpret_cast<Dart_NativeEntryResolver>(native_lookup));
 
   // Throwing an exception here should result in an error.
   result = Dart_ThrowException(NewString("This doesn't work"));
   EXPECT_ERROR(result, "No Dart frames on stack, cannot throw exception");
   EXPECT(!Dart_ErrorHasException(result));
 
   // Invoke 'test' and check for an uncaught exception.
   result = Dart_Invoke(lib, NewString("test"), 0, NULL);
   EXPECT_ERROR(result, "Hello from ExceptionNative!");
   EXPECT(Dart_ErrorHasException(result));
 
   Dart_ExitScope();  // Exit the Dart API scope.
-  EXPECT_EQ(size, state->ZoneSizeInBytes());
+  EXPECT_EQ(size, thread->ZoneSizeInBytes());
 }
 
 
 static intptr_t kNativeArgumentNativeField1Value = 30;
 static intptr_t kNativeArgumentNativeField2Value = 40;
 static intptr_t native_arg_str_peer = 100;
 static void NativeArgumentCreate(Dart_NativeArguments args) {
   Dart_Handle lib = Dart_LookupLibrary(NewString(TestCase::url()));
   Dart_Handle type = Dart_GetType(lib, NewString("MyObject"), 0, NULL);
   EXPECT_VALID(type);
@@ skipping 2801 matching lines @@
   EXPECT(out == NULL);
   EXPECT_EQ(0, isolate->heap()->PeerCount());
 }
 
 
 // Allocates an object in old space and assigns it a peer.  Removes
 // the peer and checks that the count of peer objects is decremented
 // by one.
 TEST_CASE(OneOldSpacePeer) {
   Isolate* isolate = Isolate::Current();
-  Dart_Handle str = Api::NewHandle(isolate, String::New("str", Heap::kOld));
+  Dart_Handle str = Api::NewHandle(thread, 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;
@@ skipping 12 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(Thread::Current());
-    Dart_Handle str = Api::NewHandle(isolate, String::New("str", Heap::kOld));
+    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());
     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());
 }
 
 
 // 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(isolate, String::New("s1", Heap::kOld));
+  Dart_Handle s1 = Api::NewHandle(thread, 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(isolate, String::New("s2", Heap::kOld));
+  Dart_Handle s2 = Api::NewHandle(thread, 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;
@@ skipping 13 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());
-    Dart_Handle s1 = Api::NewHandle(isolate, String::New("s1", Heap::kOld));
+    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(isolate, String::New("s2", Heap::kOld));
+    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;
@@ skipping 72 matching lines @@
     EXPECT(Dart_IsString(empty_str));
     EXPECT(Dart_IsStringLatin1(str));
     EXPECT(Dart_IsStringLatin1(empty_str));
     EXPECT(Dart_IsExternalString(str));
     EXPECT(Dart_IsExternalString(empty_str));
     EXPECT_VALID(Dart_StringLength(str, &length));
     EXPECT_EQ(0, length);
 
     // Test with single character canonical string, it should not become
     // external string but the peer should be setup for it.
-    Isolate* isolate = Isolate::Current();
-    Dart_Handle canonical_str = Api::NewHandle(isolate, Symbols::New("*"));
+    Dart_Handle canonical_str = Api::NewHandle(thread, Symbols::New("*"));
     EXPECT(Dart_IsString(canonical_str));
     EXPECT(!Dart_IsExternalString(canonical_str));
     uint8_t ext_canonical_str[kLength];
     str = Dart_MakeExternalString(canonical_str,
                                   ext_canonical_str,
                                   kLength,
                                   &canonical_str_peer,
                                   MakeExternalCback);
     EXPECT(Dart_IsString(str));
     EXPECT(!Dart_IsExternalString(canonical_str));
@@ skipping 70 matching lines @@
     EXPECT(Dart_IdentityEquals(str, utf16_str));
     for (intptr_t i = 0; i < length; i++) {
       EXPECT_EQ(0x4e8c, ext_utf16_str[i]);
     }
 
     Zone* zone = thread->zone();
     // Test with a symbol (hash value should be preserved on externalization).
     const char* symbol_ascii = "?unseen";
     expected_length = strlen(symbol_ascii);
     Dart_Handle symbol_str =
-        Api::NewHandle(isolate, Symbols::New(symbol_ascii, expected_length));
+        Api::NewHandle(thread, Symbols::New(symbol_ascii, expected_length));
     EXPECT_VALID(symbol_str);
     EXPECT(Dart_IsString(symbol_str));
     EXPECT(Dart_IsStringLatin1(symbol_str));
     EXPECT(!Dart_IsExternalString(symbol_str));
     EXPECT_VALID(Dart_StringLength(symbol_str, &length));
     EXPECT_EQ(expected_length, length);
     EXPECT(Api::UnwrapStringHandle(zone, symbol_str).HasHash());
 
     uint8_t ext_symbol_ascii[kLength];
     EXPECT_VALID(Dart_StringStorageSize(symbol_str, &size));
@@ skipping 922 matching lines @@
 
   // Heartbeat test for new events.
   EXPECT_SUBSTRING("\"name\":\"TestVMDuration2\"", buffer);
   EXPECT_SUBSTRING("\"function\":\"::_bar\"", buffer);
 
   // Free buffer allocated by AppendStreamConsumer
   free(data.buffer);
 }
 
 }  // namespace dart