- Add different types for persistent and weak persistent handles

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "include/dart_api.h"
 #include "platform/assert.h"
 #include "platform/json.h"
 #include "platform/utils.h"
 #include "vm/class_finalizer.h"
 #include "vm/dart_api_impl.h"
@@ skipping 912 matching lines @@
 static const intptr_t kExtLength = 16;
 static int8_t data[kExtLength] = { 0x41, 0x42, 0x41, 0x42,
                                    0x41, 0x42, 0x41, 0x42,
                                    0x41, 0x42, 0x41, 0x42,
                                    0x41, 0x42, 0x41, 0x42, };
 
 static void ExternalByteDataNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_Handle external_byte_data = Dart_NewExternalTypedData(kByteData,
                                                              data,
-                                                             16,
-                                                             NULL, NULL);
+                                                             16);
   EXPECT_VALID(external_byte_data);
   EXPECT_EQ(kByteData, Dart_GetTypeOfTypedData(external_byte_data));
   Dart_SetReturnValue(args, external_byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ExternalByteDataNativeResolver(Dart_Handle name,
                                                           int arg_count) {
   return &ExternalByteDataNativeFunction;
@@ skipping 153 matching lines @@
   Dart_Handle list_access_test_obj;
   list_access_test_obj = Dart_Invoke(lib, NewString("main"), 0, NULL);
   EXPECT_VALID(list_access_test_obj);
   TestDirectAccess(lib, list_access_test_obj, kInt8);
 
   // Test with an external typed data object.
   uint8_t data[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
   intptr_t data_length = ARRAY_SIZE(data);
   Dart_Handle ext_list_access_test_obj;
   ext_list_access_test_obj = Dart_NewExternalTypedData(kUint8,
-                                                       data,
-                                                       data_length,
-                                                       NULL, NULL);
+                                                       data, data_length);
   EXPECT_VALID(ext_list_access_test_obj);
   TestDirectAccess(lib, ext_list_access_test_obj, kUint8);
 }
 
 
 TEST_CASE(TypedDataViewDirectAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
@@ skipping 128 matching lines @@
   for (intptr_t i = 0; i < data_length; ++i) {
     EXPECT_EQ(33 * i, data[i]);
   }
 }
 
 
 TEST_CASE(ExternalTypedDataAccess) {
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalTypedData(kUint8,
-                                              data, data_length,
-                                              NULL, NULL);
+  Dart_Handle obj = Dart_NewExternalTypedData(kUint8, data, data_length);
   ExternalTypedDataAccessTests(obj, kUint8, data, data_length);
 }
 
 
 TEST_CASE(ExternalClampedTypedDataAccess) {
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
 
-  Dart_Handle obj = Dart_NewExternalTypedData(kUint8Clamped,
-                                              data, data_length,
-                                              NULL, NULL);
+  Dart_Handle obj = Dart_NewExternalTypedData(kUint8Clamped, data, data_length);
   ExternalTypedDataAccessTests(obj, kUint8Clamped, data, data_length);
 }
 
 
 TEST_CASE(ExternalUint8ClampedArrayAccess) {
     const char* kScriptChars =
       "testClamped(List a) {\n"
       "  if (a[1] != 11) return false;\n"
       "  a[1] = 3;\n"
       "  if (a[1] != 3) return false;\n"
       "  a[1] = -12;\n"
       "  if (a[1] != 0) return false;\n"
       "  a[1] = 1200;\n"
       "  if (a[1] != 255) return false;\n"
       "  return true;\n"
       "}\n";
 
   uint8_t data[] = { 0, 11, 22, 33, 44, 55, 66, 77 };
   intptr_t data_length = ARRAY_SIZE(data);
   Dart_Handle obj = Dart_NewExternalTypedData(kUint8Clamped,
-                                              data, data_length,
-                                              NULL, NULL);
+                                              data, data_length);
   EXPECT_VALID(obj);
   Dart_Handle result;
   // Create a test library and Load up a test script in it.
   Dart_Handle lib = TestCase::LoadTestScript(kScriptChars, NULL);
   Dart_Handle args[1];
   args[0] = obj;
   result = Dart_Invoke(lib, NewString("testClamped"), 1, args);
 
   // Check that result is true.
   EXPECT_VALID(result);
   EXPECT(Dart_IsBoolean(result));
   bool value = false;
   result = Dart_BooleanValue(result, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
-static void ExternalTypedDataCallbackFinalizer(Dart_Handle handle,
+static void ExternalTypedDataCallbackFinalizer(Dart_WeakPersistentHandle handle,
                                                void* peer) {
-  Dart_DeletePersistentHandle(handle);
+  Dart_DeleteWeakPersistentHandle(handle);
   *static_cast<int*>(peer) = 42;
 }
 
 
 TEST_CASE(ExternalTypedDataCallback) {
   int peer = 0;
   {
     Dart_EnterScope();
     uint8_t data[] = { 1, 2, 3, 4 };
     Dart_Handle obj = Dart_NewExternalTypedData(
         kUint8,
         data,
-        ARRAY_SIZE(data),
-        &peer,
-        ExternalTypedDataCallbackFinalizer);
+        ARRAY_SIZE(data));
+    Dart_NewWeakPersistentHandle(obj,
+                                 &peer,
+                                 ExternalTypedDataCallbackFinalizer);
     EXPECT_VALID(obj);
     void* api_peer = NULL;
     EXPECT_VALID(Dart_ExternalTypedDataGetPeer(obj, &api_peer));
     EXPECT_EQ(api_peer, &peer);
     Dart_ExitScope();
   }
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
@@ skipping 35 matching lines @@
 
   int peer = 0;
   float data[] = { 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0,
                    0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 };
   // Push a scope so that we can collect the local handle created as part of
   // Dart_NewExternalTypedData.
   Dart_EnterScope();
   {
-    Dart_Handle lcl = Dart_NewExternalTypedData(
-        kFloat32x4, data, 10, &peer, ExternalTypedDataCallbackFinalizer);
+    Dart_Handle lcl = Dart_NewExternalTypedData(kFloat32x4, data, 10);
+    Dart_NewWeakPersistentHandle(lcl, &peer, ExternalTypedDataCallbackFinalizer);
     CheckFloat32x4Data(lcl);
   }
   Dart_ExitScope();
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   EXPECT(peer == 42);
 }
 
 
 // Unit test for entering a scope, creating a local handle and exiting
 // the scope.
@@ skipping 23 matching lines @@
 // Unit test for creating and deleting persistent handles.
 UNIT_TEST_CASE(PersistentHandles) {
   const char* kTestString1 = "Test String1";
   const char* kTestString2 = "Test String2";
   TestCase::CreateTestIsolate();
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   ApiLocalScope* scope = state->top_scope();
-  Dart_Handle handles[2000];
+  Dart_PersistentHandle handles[2000];
   Dart_EnterScope();
   {
     DARTSCOPE(isolate);
     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++) {
@@ skipping 10 matching lines @@
     }
     VERIFY_ON_TRANSITION;
     Dart_ExitScope();
   }
   Dart_ExitScope();
   {
     StackZone zone(isolate);
     HANDLESCOPE(isolate);
     for (int i = 0; i < 500; i++) {
       String& str = String::Handle();
-      str ^= Api::UnwrapHandle(handles[i]);
+      str ^= Api::UnwrapHandle(Dart_NewHandleFromPersistent(handles[i]));
       EXPECT(str.Equals(kTestString1));
     }
     for (int i = 500; i < 1000; i++) {
       String& str = String::Handle();
-      str ^= Api::UnwrapHandle(handles[i]);
+      str ^= Api::UnwrapHandle(Dart_NewHandleFromPersistent(handles[i]));
       EXPECT(str.Equals(kTestString2));
     }
     for (int i = 1000; i < 1500; i++) {
       String& str = String::Handle();
-      str ^= Api::UnwrapHandle(handles[i]);
+      str ^= Api::UnwrapHandle(Dart_NewHandleFromPersistent(handles[i]));
       EXPECT(str.Equals(kTestString1));
     }
     for (int i = 1500; i < 2000; i++) {
       String& str = String::Handle();
-      str ^= Api::UnwrapHandle(handles[i]);
+      str ^= Api::UnwrapHandle(Dart_NewHandleFromPersistent(handles[i]));
       EXPECT(str.Equals(kTestString2));
     }
   }
   EXPECT(scope == state->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__;
 
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
   ApiState* state = isolate->api_state();
   EXPECT(state != NULL);
   DARTSCOPE(isolate);
 
   // Start with a known persistent handle.
-  Dart_Handle obj1 = Dart_True();
+  Dart_PersistentHandle obj1 = Dart_NewPersistentHandle(Dart_True());
   EXPECT(state->IsValidPersistentHandle(obj1));
 
   // And use it to allocate a second persistent handle.
-  Dart_Handle obj2 = Dart_NewPersistentHandle(obj1);
-  EXPECT(state->IsValidPersistentHandle(obj2));
+  Dart_Handle obj2 = Dart_NewHandleFromPersistent(obj1);
+  Dart_PersistentHandle obj3 = Dart_NewPersistentHandle(obj2);
+  EXPECT(state->IsValidPersistentHandle(obj3));
 
   // Make sure that the value transferred.
-  EXPECT(Dart_IsBoolean(obj2));
+  Dart_Handle obj4 = Dart_NewHandleFromPersistent(obj3);
+  EXPECT(Dart_IsBoolean(obj4));
   bool value = false;
-  Dart_Handle result = Dart_BooleanValue(obj2, &value);
+  Dart_Handle result = Dart_BooleanValue(obj4, &value);
   EXPECT_VALID(result);
   EXPECT(value);
 }
 
 
 // Helper class to ensure new gen GC is triggered without any side effects.
 // The normal call to CollectGarbage(Heap::kNew) could potentially trigger
 // an old gen collection if there is a promotion failure and this could
 // perturb the test.
 class GCTestHelper : public AllStatic {
  public:
   static void CollectNewSpace(Heap::ApiCallbacks api_callbacks) {
     bool invoke_api_callbacks = (api_callbacks == Heap::kInvokeApiCallbacks);
     Isolate::Current()->heap()->new_space_->Scavenge(invoke_api_callbacks);
   }
 };
 
 
+static Dart_Handle AsHandle(Dart_PersistentHandle weak) {
+  return Dart_NewHandleFromPersistent(weak);
+}
+
+
+static Dart_Handle AsHandle(Dart_WeakPersistentHandle weak) {
+  return Dart_NewHandleFromWeakPersistent(weak);
+}
+
+
 TEST_CASE(WeakPersistentHandle) {
-  Dart_Handle weak_new_ref = Dart_Null();
-  EXPECT(Dart_IsNull(weak_new_ref));
+  Dart_Handle local_new_ref = Dart_Null();
+  Dart_WeakPersistentHandle weak_new_ref = Dart_NewWeakPersistentHandle(
+      local_new_ref, NULL, NULL);
 
-  Dart_Handle weak_old_ref = Dart_Null();
-  EXPECT(Dart_IsNull(weak_old_ref));
+  Dart_Handle local_old_ref = Dart_Null();
+  Dart_WeakPersistentHandle weak_old_ref = Dart_NewWeakPersistentHandle(
+      local_old_ref, NULL, NULL);
 
   {
     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);
       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, NULL);
-    EXPECT_VALID(weak_new_ref);
-    EXPECT(!Dart_IsNull(weak_new_ref));
+    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, NULL);
-    EXPECT_VALID(weak_old_ref);
-    EXPECT(!Dart_IsNull(weak_old_ref));
+    EXPECT_VALID(AsHandle(weak_old_ref));
+    EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
 
     // 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(weak_new_ref);
-    EXPECT(!Dart_IsNull(weak_new_ref));
-    EXPECT(Dart_IdentityEquals(new_ref, weak_new_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(weak_old_ref);
-    EXPECT(!Dart_IsNull(weak_old_ref));
-    EXPECT(Dart_IdentityEquals(old_ref, weak_old_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);
 
     // 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(weak_new_ref);
-    EXPECT(!Dart_IsNull(weak_new_ref));
-    EXPECT(Dart_IdentityEquals(new_ref, weak_new_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(weak_old_ref);
-    EXPECT(!Dart_IsNull(weak_old_ref));
-    EXPECT(Dart_IdentityEquals(old_ref, weak_old_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);
 
   // Weak ref to new space object should now be cleared.
-  EXPECT_VALID(weak_new_ref);
-  EXPECT(Dart_IsNull(weak_new_ref));
-  EXPECT_VALID(weak_old_ref);
-  EXPECT(!Dart_IsNull(weak_old_ref));
+  EXPECT_VALID(AsHandle(weak_new_ref));
+  EXPECT(Dart_IsNull(AsHandle(weak_new_ref)));
+  EXPECT_VALID(AsHandle(weak_old_ref));
+  EXPECT(!Dart_IsNull(AsHandle(weak_old_ref)));
 
   // Garbage collect old space again.
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
 
   // Weak ref to old space object should now be cleared.
-  EXPECT_VALID(weak_new_ref);
-  EXPECT(Dart_IsNull(weak_new_ref));
-  EXPECT_VALID(weak_old_ref);
-  EXPECT(Dart_IsNull(weak_old_ref));
+  EXPECT_VALID(AsHandle(weak_new_ref));
+  EXPECT(Dart_IsNull(AsHandle(weak_new_ref)));
+  EXPECT_VALID(AsHandle(weak_old_ref));
+  EXPECT(Dart_IsNull(AsHandle(weak_old_ref)));
 
-  Dart_DeletePersistentHandle(weak_new_ref);
-  Dart_DeletePersistentHandle(weak_old_ref);
+  Dart_DeleteWeakPersistentHandle(weak_new_ref);
+  Dart_DeleteWeakPersistentHandle(weak_old_ref);
 
   // Garbage collect one last time to revisit deleted handles.
   Isolate::Current()->heap()->CollectGarbage(Heap::kNew);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
 }
 
 
-static void WeakPersistentHandlePeerFinalizer(Dart_Handle handle, void* peer) {
+static void WeakPersistentHandlePeerFinalizer(Dart_WeakPersistentHandle handle, void* peer) {
   *static_cast<int*>(peer) = 42;
 }
 
 
 TEST_CASE(WeakPersistentHandleCallback) {
-  Dart_Handle weak_ref = Dart_Null();
-  EXPECT(Dart_IsNull(weak_ref));
+  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,
                                             WeakPersistentHandlePeerFinalizer);
     Dart_ExitScope();
   }
-  EXPECT_VALID(weak_ref);
+  EXPECT_VALID(AsHandle(weak_ref));
   EXPECT(peer == 0);
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   EXPECT(peer == 0);
   GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
   EXPECT(peer == 42);
-  Dart_DeletePersistentHandle(weak_ref);
+  Dart_DeleteWeakPersistentHandle(weak_ref);
 }
 
 
 TEST_CASE(WeakPersistentHandleNoCallback) {
-  Dart_Handle weak_ref = Dart_Null();
-  EXPECT(Dart_IsNull(weak_ref));
+  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,
                                             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_DeletePersistentHandle(weak_ref);
-  EXPECT_VALID(weak_ref);
+  Dart_DeleteWeakPersistentHandle(weak_ref);
   EXPECT(peer == 0);
   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,
                                WeakPersistentHandlePeerFinalizer);
   Dart_ShutdownIsolate();
   EXPECT(peer == 42);
 }
 
 
 TEST_CASE(ObjectGroups) {
-  Dart_Handle strong = Dart_Null();
-  EXPECT(Dart_IsNull(strong));
+  Dart_PersistentHandle strong = NULL;
+  Dart_WeakPersistentHandle strong_weak = NULL;
 
-  Dart_Handle weak1 = Dart_Null();
-  EXPECT(Dart_IsNull(weak1));
-
-  Dart_Handle weak2 = Dart_Null();
-  EXPECT(Dart_IsNull(weak2));
-
-  Dart_Handle weak3 = Dart_Null();
-  EXPECT(Dart_IsNull(weak3));
-
-  Dart_Handle weak4 = Dart_Null();
-  EXPECT(Dart_IsNull(weak4));
+  Dart_WeakPersistentHandle weak1 = NULL;
+  Dart_WeakPersistentHandle weak2 = NULL;
+  Dart_WeakPersistentHandle weak3 = NULL;
+  Dart_WeakPersistentHandle weak4 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
 
-    strong = Dart_NewPersistentHandle(
-        Api::NewHandle(isolate, String::New("strongly reachable", Heap::kOld)));
-    EXPECT_VALID(strong);
-    EXPECT(!Dart_IsNull(strong));
+    Dart_Handle local = Api::NewHandle(isolate, String::New("strongly reachable", Heap::kOld));
+    strong = Dart_NewPersistentHandle(local);
+    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
+    EXPECT_VALID(AsHandle(strong));
+    EXPECT(!Dart_IsNull(AsHandle(strong)));
+    
 
     weak1 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 1", Heap::kOld)),
         NULL, NULL);
-    EXPECT_VALID(weak1);
-    EXPECT(!Dart_IsNull(weak1));
+    EXPECT_VALID(AsHandle(weak1));
+    EXPECT(!Dart_IsNull(AsHandle(weak1)));
 
     weak2 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kOld)),
         NULL, NULL);
-    EXPECT_VALID(weak2);
-    EXPECT(!Dart_IsNull(weak2));
+    EXPECT_VALID(AsHandle(weak2));
+    EXPECT(!Dart_IsNull(AsHandle(weak2)));
 
     weak3 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kOld)),
         NULL, NULL);
-    EXPECT_VALID(weak3);
-    EXPECT(!Dart_IsNull(weak3));
+    EXPECT_VALID(AsHandle(weak3));
+    EXPECT(!Dart_IsNull(AsHandle(weak3)));
 
     weak4 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 4", Heap::kOld)),
         NULL, NULL);
-    EXPECT_VALID(weak4);
-    EXPECT(!Dart_IsNull(weak4));
+    EXPECT_VALID(AsHandle(weak4));
+    EXPECT(!Dart_IsNull(AsHandle(weak4)));
   }
   Dart_ExitScope();
 
-  EXPECT_VALID(strong);
+  EXPECT_VALID(AsHandle(strong));
 
-  EXPECT_VALID(weak1);
-  EXPECT_VALID(weak2);
-  EXPECT_VALID(weak3);
-  EXPECT_VALID(weak4);
+  EXPECT_VALID(AsHandle(weak1));
+  EXPECT_VALID(AsHandle(weak2));
+  EXPECT_VALID(AsHandle(weak3));
+  EXPECT_VALID(AsHandle(weak4));
 
   GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
   // New space collection should not affect old space objects
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(!Dart_IsNull(weak3));
-  EXPECT(!Dart_IsNull(weak4));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(!Dart_IsNull(AsHandle(weak3)));
+  EXPECT(!Dart_IsNull(AsHandle(weak4)));
 
   {
-    Dart_Handle array1[] = { weak1, strong };
+    Dart_WeakPersistentHandle array1[] = { weak1, strong_weak };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
                                           array1, ARRAY_SIZE(array1)));
 
-    Dart_Handle array2[] = { weak2, weak1 };
+    Dart_WeakPersistentHandle array2[] = { weak2, weak1 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
                                           array2, ARRAY_SIZE(array2)));
 
-    Dart_Handle array3[] = { weak3, weak2 };
+    Dart_WeakPersistentHandle array3[] = { weak3, weak2 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array3, ARRAY_SIZE(array3),
                                           array3, ARRAY_SIZE(array3)));
 
-    Dart_Handle array4[] = { weak4, weak3 };
+    Dart_WeakPersistentHandle array4[] = { weak4, weak3 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array4, ARRAY_SIZE(array4),
                                           array4, ARRAY_SIZE(array4)));
 
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   }
 
   // All weak references should be preserved.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(!Dart_IsNull(weak3));
-  EXPECT(!Dart_IsNull(weak4));
+  EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(!Dart_IsNull(AsHandle(weak3)));
+  EXPECT(!Dart_IsNull(AsHandle(weak4)));
 
   {
-    Dart_Handle array1[] = { weak1, strong };
+    Dart_WeakPersistentHandle array1[] = { weak1, strong_weak };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
                                           array1, ARRAY_SIZE(array1)));
 
-    Dart_Handle array2[] = { weak2, weak1 };
+    Dart_WeakPersistentHandle array2[] = { weak2, weak1 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
                                           array2, ARRAY_SIZE(array2)));
 
-    Dart_Handle array3[] = { weak2 };
+    Dart_WeakPersistentHandle array3[] = { weak2 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array3, ARRAY_SIZE(array3),
                                           array3, ARRAY_SIZE(array3)));
 
     // Strong reference to weak3 to retain weak3 and weak4.
-    Dart_Handle weak3_strong_ref = Dart_NewPersistentHandle(weak3);
-    EXPECT_VALID(weak3_strong_ref);
+    Dart_PersistentHandle weak3_strong_ref = Dart_NewPersistentHandle(AsHandle(weak3));
+    EXPECT_VALID(AsHandle(weak3_strong_ref));
 
-    Dart_Handle array4[] = { weak4, weak3 };
+    Dart_WeakPersistentHandle array4[] = { weak4, weak3 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array4, ARRAY_SIZE(array4),
                                           array4, ARRAY_SIZE(array4)));
 
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
 
     // Delete strong reference to weak3.
     Dart_DeletePersistentHandle(weak3_strong_ref);
   }
 
   // All weak references should be preserved.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(!Dart_IsNull(weak3));
-  EXPECT(!Dart_IsNull(weak4));
+  EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(!Dart_IsNull(AsHandle(weak3)));
+  EXPECT(!Dart_IsNull(AsHandle(weak4)));
 
   {
-    Dart_Handle array1[] = { weak1, strong };
+    Dart_WeakPersistentHandle array1[] = { weak1, strong_weak };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
                                           array1, ARRAY_SIZE(array1)));
 
-    Dart_Handle array2[] = { weak2, weak1 };
+    Dart_WeakPersistentHandle array2[] = { weak2, weak1 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
                                           array2, ARRAY_SIZE(array2)));
 
-    Dart_Handle array3[] = { weak2 };
+    Dart_WeakPersistentHandle array3[] = { weak2 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array3, ARRAY_SIZE(array3),
                                           array3, ARRAY_SIZE(array3)));
 
-    Dart_Handle array4[] = { weak4, weak3 };
+    Dart_WeakPersistentHandle array4[] = { weak4, weak3 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array4, ARRAY_SIZE(array4),
                                           array4, ARRAY_SIZE(array4)));
 
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   }
 
   // Only weak1 and weak2 should be preserved.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(Dart_IsNull(weak3));
-  EXPECT(Dart_IsNull(weak4));
+  EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(Dart_IsNull(AsHandle(weak3)));
+  EXPECT(Dart_IsNull(AsHandle(weak4)));
 
   {
-    Dart_Handle array1[] = { weak1, strong };
+    Dart_WeakPersistentHandle array1[] = { weak1, strong_weak };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
                                           array1, ARRAY_SIZE(array1)));
 
     // weak3 is cleared so weak2 is unreferenced and should be cleared
-    Dart_Handle array2[] = { weak2, weak3 };
+    Dart_WeakPersistentHandle array2[] = { weak2, weak3 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
                                           array2, ARRAY_SIZE(array2)));
 
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   }
 
   // Only weak1 should be preserved, weak3 should not preserve weak2.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(Dart_IsNull(weak2));
-  EXPECT(Dart_IsNull(weak3));  // was cleared, should remain cleared
-  EXPECT(Dart_IsNull(weak4));  // was cleared, should remain cleared
+  EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(Dart_IsNull(AsHandle(weak2)));
+  EXPECT(Dart_IsNull(AsHandle(weak3)));  // was cleared, should remain cleared
+  EXPECT(Dart_IsNull(AsHandle(weak4)));  // was cleared, should remain cleared
 
   {
     // weak{2,3,4} are cleared and should have no effect on weak1
-    Dart_Handle array1[] = { strong, weak2, weak3, weak4 };
+    Dart_WeakPersistentHandle array1[] = { strong_weak, weak2, weak3, weak4 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array1, ARRAY_SIZE(array1),
                                           array1, ARRAY_SIZE(array1)));
 
     // weak1 is weakly reachable and should be cleared
-    Dart_Handle array2[] = { weak1 };
+    Dart_WeakPersistentHandle array2[] = { weak1 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(array2, ARRAY_SIZE(array2),
                                           array2, ARRAY_SIZE(array2)));
 
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   }
 
   // All weak references should now be cleared.
-  EXPECT(Dart_IsNull(weak1));
-  EXPECT(Dart_IsNull(weak2));
-  EXPECT(Dart_IsNull(weak3));
-  EXPECT(Dart_IsNull(weak4));
+  EXPECT(!Dart_IsNull(AsHandle(strong_weak)));
+  EXPECT(Dart_IsNull(AsHandle(weak1)));
+  EXPECT(Dart_IsNull(AsHandle(weak2)));
+  EXPECT(Dart_IsNull(AsHandle(weak3)));
+  EXPECT(Dart_IsNull(AsHandle(weak4)));
 }
 
 
 TEST_CASE(PrologueWeakPersistentHandles) {
-  Dart_Handle old_pwph = Dart_Null();
-  EXPECT(Dart_IsNull(old_pwph));
-  Dart_Handle new_pwph = Dart_Null();
-  EXPECT(Dart_IsNull(new_pwph));
+  Dart_WeakPersistentHandle old_pwph = NULL;
+  Dart_WeakPersistentHandle new_pwph = NULL;
+
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
     new_pwph = Dart_NewPrologueWeakPersistentHandle(
         Api::NewHandle(isolate,
                        String::New("new space prologue weak", Heap::kNew)),
         NULL, NULL);
-    EXPECT_VALID(new_pwph);
-    EXPECT(!Dart_IsNull(new_pwph));
+    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, NULL);
-    EXPECT_VALID(old_pwph);
-    EXPECT(!Dart_IsNull(old_pwph));
+    EXPECT_VALID(AsHandle(old_pwph));
+    EXPECT(!Dart_IsNull(AsHandle(old_pwph)));
   }
   Dart_ExitScope();
-  EXPECT_VALID(new_pwph);
-  EXPECT(!Dart_IsNull(new_pwph));
+  EXPECT_VALID(AsHandle(new_pwph));
+  EXPECT(!Dart_IsNull(AsHandle(new_pwph)));
   EXPECT(Dart_IsPrologueWeakPersistentHandle(new_pwph));
-  EXPECT_VALID(old_pwph);
-  EXPECT(!Dart_IsNull(old_pwph));
+  EXPECT_VALID(AsHandle(old_pwph));
+  EXPECT(!Dart_IsNull(AsHandle(old_pwph)));
   EXPECT(Dart_IsPrologueWeakPersistentHandle(old_pwph));
   // Garbage collect new space without invoking API callbacks.
   GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
   // Both prologue weak handles should be preserved.
-  EXPECT(!Dart_IsNull(new_pwph));
-  EXPECT(!Dart_IsNull(old_pwph));
+  EXPECT(!Dart_IsNull(AsHandle(new_pwph)));
+  EXPECT(!Dart_IsNull(AsHandle(old_pwph)));
   // Garbage collect old space without invoking API callbacks.
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
                                              Heap::kIgnoreApiCallbacks);
   // Both prologue weak handles should be preserved.
-  EXPECT(!Dart_IsNull(new_pwph));
-  EXPECT(!Dart_IsNull(old_pwph));
+  EXPECT(!Dart_IsNull(AsHandle(new_pwph)));
+  EXPECT(!Dart_IsNull(AsHandle(old_pwph)));
   // Garbage collect new space invoking API callbacks.
   GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
 
   // The prologue weak handle with a new space referent should now be
   // cleared.  The old space referent should be preserved.
-  EXPECT(Dart_IsNull(new_pwph));
-  EXPECT(!Dart_IsNull(old_pwph));
+  EXPECT(Dart_IsNull(AsHandle(new_pwph)));
+  EXPECT(!Dart_IsNull(AsHandle(old_pwph)));
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld,
                                              Heap::kInvokeApiCallbacks);
   // The prologue weak handle with an old space referent should now be
   // cleared.  The new space referent should remain cleared.
-  EXPECT(Dart_IsNull(new_pwph));
-  EXPECT(Dart_IsNull(old_pwph));
+  EXPECT(Dart_IsNull(AsHandle(new_pwph)));
+  EXPECT(Dart_IsNull(AsHandle(old_pwph)));
 }
 
 
 TEST_CASE(ImplicitReferencesOldSpace) {
-  Dart_Handle strong = Dart_Null();
-  EXPECT(Dart_IsNull(strong));
+  Dart_PersistentHandle strong = NULL;
+  Dart_WeakPersistentHandle strong_weak = NULL;
 
-  Dart_Handle weak1 = Dart_Null();
-  EXPECT(Dart_IsNull(weak1));
-
-  Dart_Handle weak2 = Dart_Null();
-  EXPECT(Dart_IsNull(weak2));
-
-  Dart_Handle weak3 = Dart_Null();
-  EXPECT(Dart_IsNull(weak3));
+  Dart_WeakPersistentHandle weak1 = NULL;
+  Dart_WeakPersistentHandle weak2 = NULL;
+  Dart_WeakPersistentHandle weak3 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
 
-    strong = Dart_NewPersistentHandle(
-        Api::NewHandle(isolate, String::New("strongly reachable", Heap::kOld)));
-    EXPECT(!Dart_IsNull(strong));
-    EXPECT_VALID(strong);
+    Dart_Handle local = Api::NewHandle(isolate, String::New("strongly reachable", Heap::kOld));
+    strong = Dart_NewPersistentHandle(local);
+    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
+
+    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)),
         NULL, NULL);
-    EXPECT(!Dart_IsNull(weak1));
-    EXPECT_VALID(weak1);
+    EXPECT(!Dart_IsNull(AsHandle(weak1)));
+    EXPECT_VALID(AsHandle(weak1));
 
     weak2 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kOld)),
         NULL, NULL);
-    EXPECT(!Dart_IsNull(weak2));
-    EXPECT_VALID(weak2);
+    EXPECT(!Dart_IsNull(AsHandle(weak2)));
+    EXPECT_VALID(AsHandle(weak2));
 
     weak3 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kOld)),
         NULL, NULL);
-    EXPECT(!Dart_IsNull(weak3));
-    EXPECT_VALID(weak3);
+    EXPECT(!Dart_IsNull(AsHandle(weak3)));
+    EXPECT_VALID(AsHandle(weak3));
   }
   Dart_ExitScope();
 
-  EXPECT_VALID(strong);
-
-  EXPECT_VALID(weak1);
-  EXPECT_VALID(weak2);
-  EXPECT_VALID(weak3);
+  EXPECT_VALID(AsHandle(strong_weak));
+  EXPECT_VALID(AsHandle(weak1));
+  EXPECT_VALID(AsHandle(weak2));
+  EXPECT_VALID(AsHandle(weak3));
 
   GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
   // New space collection should not affect old space objects
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(!Dart_IsNull(weak3));
+  EXPECT_VALID(AsHandle(strong_weak));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(!Dart_IsNull(AsHandle(weak3)));
 
   // A strongly referenced key should preserve all the values.
   {
-    Dart_Handle keys[] = { strong };
-    Dart_Handle values[] = { weak1, weak2, weak3 };
+    Dart_WeakPersistentHandle keys[] = { strong_weak };
+    Dart_WeakPersistentHandle values[] = { weak1, weak2, weak3 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(keys, ARRAY_SIZE(keys),
                                           values, ARRAY_SIZE(values)));
 
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   }
 
   // All weak references should be preserved.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(!Dart_IsNull(weak3));
+  EXPECT_VALID(AsHandle(strong_weak));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(!Dart_IsNull(AsHandle(weak3)));
 
   // Key membership does not imply a strong reference.
   {
-    Dart_Handle keys[] = { strong, weak3 };
-    Dart_Handle values[] = { weak1, weak2 };
+    Dart_WeakPersistentHandle keys[] = { strong_weak, weak3 };
+    Dart_WeakPersistentHandle values[] = { weak1, weak2 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(keys, ARRAY_SIZE(keys),
                                           values, ARRAY_SIZE(values)));
 
     Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
   }
 
   // All weak references except weak3 should be preserved.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(Dart_IsNull(weak3));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(Dart_IsNull(AsHandle(weak3)));
 }
 
 
 TEST_CASE(ImplicitReferencesNewSpace) {
-  Dart_Handle strong = Dart_Null();
-  EXPECT(Dart_IsNull(strong));
-
-  Dart_Handle weak1 = Dart_Null();
-  EXPECT(Dart_IsNull(weak1));
-
-  Dart_Handle weak2 = Dart_Null();
-  EXPECT(Dart_IsNull(weak2));
-
-  Dart_Handle weak3 = Dart_Null();
-  EXPECT(Dart_IsNull(weak3));
+  Dart_PersistentHandle strong = NULL;
+  Dart_WeakPersistentHandle strong_weak = NULL;
+  
+  Dart_WeakPersistentHandle weak1 = NULL;
+  Dart_WeakPersistentHandle weak2 = NULL;
+  Dart_WeakPersistentHandle weak3 = NULL;
 
   Dart_EnterScope();
   {
     Isolate* isolate = Isolate::Current();
     DARTSCOPE(isolate);
 
-    strong = Dart_NewPersistentHandle(
-        Api::NewHandle(isolate, String::New("strongly reachable", Heap::kNew)));
-    EXPECT(!Dart_IsNull(strong));
-    EXPECT_VALID(strong);
+    Dart_Handle local = Api::NewHandle(isolate, String::New("strongly reachable", Heap::kOld));
+    strong = Dart_NewPersistentHandle(local);
+    strong_weak = Dart_NewWeakPersistentHandle(local, NULL, NULL);
+    
+    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)),
         NULL, NULL);
-    EXPECT(!Dart_IsNull(weak1));
-    EXPECT_VALID(weak1);
+    EXPECT(!Dart_IsNull(AsHandle(weak1)));
+    EXPECT_VALID(AsHandle(weak1));
 
     weak2 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 2", Heap::kNew)),
         NULL, NULL);
-    EXPECT(!Dart_IsNull(weak2));
-    EXPECT_VALID(weak2);
+    EXPECT(!Dart_IsNull(AsHandle(weak2)));
+    EXPECT_VALID(AsHandle(weak2));
 
     weak3 = Dart_NewWeakPersistentHandle(
         Api::NewHandle(isolate, String::New("weakly reachable 3", Heap::kNew)),
         NULL, NULL);
-    EXPECT(!Dart_IsNull(weak3));
-    EXPECT_VALID(weak3);
+    EXPECT(!Dart_IsNull(AsHandle(weak3)));
+    EXPECT_VALID(AsHandle(weak3));
   }
   Dart_ExitScope();
 
-  EXPECT_VALID(strong);
-
-  EXPECT_VALID(weak1);
-  EXPECT_VALID(weak2);
-  EXPECT_VALID(weak3);
+  EXPECT_VALID(AsHandle(strong_weak));
+  EXPECT_VALID(AsHandle(weak1));
+  EXPECT_VALID(AsHandle(weak2));
+  EXPECT_VALID(AsHandle(weak3));
 
   Isolate::Current()->heap()->CollectGarbage(Heap::kOld);
 
   // Old space collection should not affect old space objects.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(!Dart_IsNull(weak3));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(!Dart_IsNull(AsHandle(weak3)));
 
   // A strongly referenced key should preserve all the values.
   {
-    Dart_Handle keys[] = { strong };
-    Dart_Handle values[] = { weak1, weak2, weak3 };
+    Dart_WeakPersistentHandle keys[] = { strong_weak };
+    Dart_WeakPersistentHandle values[] = { weak1, weak2, weak3 };
     EXPECT_VALID(Dart_NewWeakReferenceSet(keys, ARRAY_SIZE(keys),
                                           values, ARRAY_SIZE(values)));
 
     GCTestHelper::CollectNewSpace(Heap::kInvokeApiCallbacks);
   }
 
   // All weak references should be preserved.
-  EXPECT(!Dart_IsNull(weak1));
-  EXPECT(!Dart_IsNull(weak2));
-  EXPECT(!Dart_IsNull(weak3));
+  EXPECT(!Dart_IsNull(AsHandle(weak1)));
+  EXPECT(!Dart_IsNull(AsHandle(weak2)));
+  EXPECT(!Dart_IsNull(AsHandle(weak3)));
 
   GCTestHelper::CollectNewSpace(Heap::kIgnoreApiCallbacks);
 
   // No weak references should be preserved.
-  EXPECT(Dart_IsNull(weak1));
-  EXPECT(Dart_IsNull(weak2));
-  EXPECT(Dart_IsNull(weak3));
+  EXPECT(Dart_IsNull(AsHandle(weak1)));
+  EXPECT(Dart_IsNull(AsHandle(weak2)));
+  EXPECT(Dart_IsNull(AsHandle(weak3)));
 }
 
 
 static int global_prologue_callback_status;
 
 
 static void PrologueCallbackTimes2() {
   global_prologue_callback_status *= 2;
 }
 
@@ skipping 5612 matching lines @@
                                    NewString("main"),
                                    0,
                                    NULL);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(260, value);
 }
 
 }  // namespace dart