Remove internal uses of deprecated MakeWeak.

test/cctest/test-api.cc

Index: test/cctest/test-api.cc
diff --git a/test/cctest/test-api.cc b/test/cctest/test-api.cc
index 2e457d0e8e5cb8006be69d735fc068730a3aa2d4..e33f6ff346490bce96f149ba291782d143213768 100644
--- a/test/cctest/test-api.cc
+++ b/test/cctest/test-api.cc
@@ -29,6 +29,7 @@
 #include <csignal>
 #include <string>
 #include <map>
+#include <utility>

[Michael Starzinger, 2013/12/02 15:34:10]

nit: Can we alpha-sort the system includes block?

[Sven Panne, 2013/12/02 17:30:53]

Done.

 
 #include "v8.h"
 
@@ -53,6 +54,8 @@
 
 static const bool kLogThreading = false;
 
+using std::pair;
+
 using ::v8::Boolean;
 using ::v8::BooleanObject;
 using ::v8::Context;
@@ -3445,12 +3448,12 @@ class WeakCallCounter {
 
 
 template<typename T>
-static void WeakPointerCallback(v8::Isolate* isolate,
-                                Persistent<T>* handle,
-                                WeakCallCounter* counter) {
-  CHECK_EQ(1234, counter->id());
-  counter->increment();
-  handle->Reset();
+static void WeakPointerCallback(
+    const v8::WeakCallbackData<T, std::pair<v8::Persistent<T>*,
+                                            WeakCallCounter*> >& data) {
+  CHECK_EQ(1234, data.GetParameter()->second->id());
+  data.GetParameter()->second->increment();
+  data.GetParameter()->first->Reset();
 }
 
 
@@ -3474,24 +3477,32 @@ THREADED_TEST(ApiObjectGroups) {
 
   WeakCallCounter counter(1234);
 
+  pair<Persistent<Value>*, WeakCallCounter*> g1s1p(&g1s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g1s2p(&g1s2, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g1c1p(&g1c1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g2s1p(&g2s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g2s2p(&g2s2, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g2c1p(&g2c1, &counter);
+
   {
     HandleScope scope(iso);
     g1s1.Reset(iso, Object::New());
     g1s2.Reset(iso, Object::New());
     g1c1.Reset(iso, Object::New());
-    g1s1.MakeWeak(&counter, &WeakPointerCallback);
-    g1s2.MakeWeak(&counter, &WeakPointerCallback);
-    g1c1.MakeWeak(&counter, &WeakPointerCallback);
+    g1s1.SetWeak(&g1s1p, &WeakPointerCallback);
+    g1s2.SetWeak(&g1s2p, &WeakPointerCallback);
+    g1c1.SetWeak(&g1c1p, &WeakPointerCallback);
 
     g2s1.Reset(iso, Object::New());
     g2s2.Reset(iso, Object::New());
     g2c1.Reset(iso, Object::New());
-    g2s1.MakeWeak(&counter, &WeakPointerCallback);
-    g2s2.MakeWeak(&counter, &WeakPointerCallback);
-    g2c1.MakeWeak(&counter, &WeakPointerCallback);
+    g2s1.SetWeak(&g2s1p, &WeakPointerCallback);
+    g2s2.SetWeak(&g2s2p, &WeakPointerCallback);
+    g2c1.SetWeak(&g2c1p, &WeakPointerCallback);
   }
 
   Persistent<Value> root(iso, g1s1);  // make a root.
+  pair<Persistent<Value>*, WeakCallCounter*> rootp(&root, &counter);
 
   // Connect group 1 and 2, make a cycle.
   {
@@ -3521,7 +3532,7 @@ THREADED_TEST(ApiObjectGroups) {
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
-  root.MakeWeak(&counter, &WeakPointerCallback);
+  root.SetWeak(&rootp, &WeakPointerCallback);
   // But make children strong roots---all the objects (except for children)
   // should be collectable now.
   g1c1.ClearWeak();
@@ -3545,8 +3556,8 @@ THREADED_TEST(ApiObjectGroups) {
   CHECK_EQ(5, counter.NumberOfWeakCalls());
 
   // And now make children weak again and collect them.
-  g1c1.MakeWeak(&counter, &WeakPointerCallback);
-  g2c1.MakeWeak(&counter, &WeakPointerCallback);
+  g1c1.SetWeak(&g1c1p, &WeakPointerCallback);
+  g2c1.SetWeak(&g2c1p, &WeakPointerCallback);
 
   heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
   CHECK_EQ(7, counter.NumberOfWeakCalls());
@@ -3567,24 +3578,32 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) {
 
   WeakCallCounter counter(1234);
 
+  pair<Persistent<Object>*, WeakCallCounter*> g1s1p(&g1s1, &counter);
+  pair<Persistent<String>*, WeakCallCounter*> g1s2p(&g1s2, &counter);
+  pair<Persistent<String>*, WeakCallCounter*> g1c1p(&g1c1, &counter);
+  pair<Persistent<Object>*, WeakCallCounter*> g2s1p(&g2s1, &counter);
+  pair<Persistent<String>*, WeakCallCounter*> g2s2p(&g2s2, &counter);
+  pair<Persistent<String>*, WeakCallCounter*> g2c1p(&g2c1, &counter);
+
   {
     HandleScope scope(iso);
     g1s1.Reset(iso, Object::New());
     g1s2.Reset(iso, String::NewFromUtf8(iso, "foo1"));
     g1c1.Reset(iso, String::NewFromUtf8(iso, "foo2"));
-    g1s1.MakeWeak(&counter, &WeakPointerCallback);
-    g1s2.MakeWeak(&counter, &WeakPointerCallback);
-    g1c1.MakeWeak(&counter, &WeakPointerCallback);
+    g1s1.SetWeak(&g1s1p, &WeakPointerCallback);
+    g1s2.SetWeak(&g1s2p, &WeakPointerCallback);
+    g1c1.SetWeak(&g1c1p, &WeakPointerCallback);
 
     g2s1.Reset(iso, Object::New());
     g2s2.Reset(iso, String::NewFromUtf8(iso, "foo3"));
     g2c1.Reset(iso, String::NewFromUtf8(iso, "foo4"));
-    g2s1.MakeWeak(&counter, &WeakPointerCallback);
-    g2s2.MakeWeak(&counter, &WeakPointerCallback);
-    g2c1.MakeWeak(&counter, &WeakPointerCallback);
+    g2s1.SetWeak(&g2s1p, &WeakPointerCallback);
+    g2s2.SetWeak(&g2s2p, &WeakPointerCallback);
+    g2c1.SetWeak(&g2c1p, &WeakPointerCallback);
   }
 
   Persistent<Value> root(iso, g1s1);  // make a root.
+  pair<Persistent<Value>*, WeakCallCounter*> rootp(&root, &counter);
 
   // Connect group 1 and 2, make a cycle.
   {
@@ -3612,7 +3631,7 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) {
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
-  root.MakeWeak(&counter, &WeakPointerCallback);
+  root.SetWeak(&rootp, &WeakPointerCallback);
   // But make children strong roots---all the objects (except for children)
   // should be collectable now.
   g1c1.ClearWeak();
@@ -3636,8 +3655,8 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) {
   CHECK_EQ(5, counter.NumberOfWeakCalls());
 
   // And now make children weak again and collect them.
-  g1c1.MakeWeak(&counter, &WeakPointerCallback);
-  g2c1.MakeWeak(&counter, &WeakPointerCallback);
+  g1c1.SetWeak(&g1c1p, &WeakPointerCallback);
+  g2c1.SetWeak(&g2c1p, &WeakPointerCallback);
 
   heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
   CHECK_EQ(7, counter.NumberOfWeakCalls());
@@ -3660,38 +3679,48 @@ THREADED_TEST(ApiObjectGroupsCycle) {
   Persistent<Value> g4s1;
   Persistent<Value> g4s2;
 
+  pair<Persistent<Value>*, WeakCallCounter*> g1s1p(&g1s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g1s2p(&g1s2, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g2s1p(&g2s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g2s2p(&g2s2, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g3s1p(&g3s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g3s2p(&g3s2, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g4s1p(&g4s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g4s2p(&g4s2, &counter);
+
   {
     HandleScope scope(iso);
     g1s1.Reset(iso, Object::New());
     g1s2.Reset(iso, Object::New());
-    g1s1.MakeWeak(&counter, &WeakPointerCallback);
-    g1s2.MakeWeak(&counter, &WeakPointerCallback);
+    g1s1.SetWeak(&g1s1p, &WeakPointerCallback);
+    g1s2.SetWeak(&g1s2p, &WeakPointerCallback);
     CHECK(g1s1.IsWeak());
     CHECK(g1s2.IsWeak());
 
     g2s1.Reset(iso, Object::New());
     g2s2.Reset(iso, Object::New());
-    g2s1.MakeWeak(&counter, &WeakPointerCallback);
-    g2s2.MakeWeak(&counter, &WeakPointerCallback);
+    g2s1.SetWeak(&g2s1p, &WeakPointerCallback);
+    g2s2.SetWeak(&g2s2p, &WeakPointerCallback);
     CHECK(g2s1.IsWeak());
     CHECK(g2s2.IsWeak());
 
     g3s1.Reset(iso, Object::New());
     g3s2.Reset(iso, Object::New());
-    g3s1.MakeWeak(&counter, &WeakPointerCallback);
-    g3s2.MakeWeak(&counter, &WeakPointerCallback);
+    g3s1.SetWeak(&g3s1p, &WeakPointerCallback);
+    g3s2.SetWeak(&g3s2p, &WeakPointerCallback);
     CHECK(g3s1.IsWeak());
     CHECK(g3s2.IsWeak());
 
     g4s1.Reset(iso, Object::New());
     g4s2.Reset(iso, Object::New());
-    g4s1.MakeWeak(&counter, &WeakPointerCallback);
-    g4s2.MakeWeak(&counter, &WeakPointerCallback);
+    g4s1.SetWeak(&g4s1p, &WeakPointerCallback);
+    g4s2.SetWeak(&g4s2p, &WeakPointerCallback);
     CHECK(g4s1.IsWeak());
     CHECK(g4s2.IsWeak());
   }
 
   Persistent<Value> root(iso, g1s1);  // make a root.
+  pair<Persistent<Value>*, WeakCallCounter*> rootp(&root, &counter);
 
   // Connect groups.  We're building the following cycle:
   // G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other
@@ -3723,7 +3752,7 @@ THREADED_TEST(ApiObjectGroupsCycle) {
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
-  root.MakeWeak(&counter, &WeakPointerCallback);
+  root.SetWeak(&rootp, &WeakPointerCallback);
 
   // Groups are deleted, rebuild groups.
   {
@@ -3770,26 +3799,34 @@ TEST(ApiObjectGroupsCycleForScavenger) {
   Persistent<Value> g3s1;
   Persistent<Value> g3s2;
 
+  pair<Persistent<Value>*, WeakCallCounter*> g1s1p(&g1s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g1s2p(&g1s2, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g2s1p(&g2s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g2s2p(&g2s2, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g3s1p(&g3s1, &counter);
+  pair<Persistent<Value>*, WeakCallCounter*> g3s2p(&g3s2, &counter);
+
   {
     HandleScope scope(iso);
     g1s1.Reset(iso, Object::New());
     g1s2.Reset(iso, Object::New());
-    g1s1.MakeWeak(&counter, &WeakPointerCallback);
-    g1s2.MakeWeak(&counter, &WeakPointerCallback);
+    g1s1.SetWeak(&g1s1p, &WeakPointerCallback);
+    g1s2.SetWeak(&g1s2p, &WeakPointerCallback);
 
     g2s1.Reset(iso, Object::New());
     g2s2.Reset(iso, Object::New());
-    g2s1.MakeWeak(&counter, &WeakPointerCallback);
-    g2s2.MakeWeak(&counter, &WeakPointerCallback);
+    g2s1.SetWeak(&g2s1p, &WeakPointerCallback);
+    g2s2.SetWeak(&g2s2p, &WeakPointerCallback);
 
     g3s1.Reset(iso, Object::New());
     g3s2.Reset(iso, Object::New());
-    g3s1.MakeWeak(&counter, &WeakPointerCallback);
-    g3s2.MakeWeak(&counter, &WeakPointerCallback);
+    g3s1.SetWeak(&g3s1p, &WeakPointerCallback);
+    g3s2.SetWeak(&g3s2p, &WeakPointerCallback);
   }
 
   // Make a root.
   Persistent<Value> root(iso, g1s1);
+  pair<Persistent<Value>*, WeakCallCounter*> rootp(&root, &counter);
   root.MarkPartiallyDependent();
 
   // Connect groups.  We're building the following cycle:
@@ -3825,7 +3862,7 @@ TEST(ApiObjectGroupsCycleForScavenger) {
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
-  root.MakeWeak(&counter, &WeakPointerCallback);
+  root.SetWeak(&rootp, &WeakPointerCallback);
   root.MarkPartiallyDependent();
 
   // Groups are deleted, rebuild groups.
@@ -6949,7 +6986,9 @@ int global_index = 0;
 
 class Snorkel {
  public:
-  Snorkel() { index_ = global_index++; }
+  explicit Snorkel(v8::Persistent<v8::Object>* prev)
+      : prev_(prev), index_(global_index++) { }
+  v8::Persistent<v8::Object>* prev_;
   int index_;
 };
 
@@ -6970,11 +7009,10 @@ class Whammy {
   v8::Persistent<Script> script_;
 };
 
-static void HandleWeakReference(v8::Isolate* isolate,
-                                v8::Persistent<v8::Value>* obj,
-                                Snorkel* snorkel) {
-  delete snorkel;
-  obj->ClearWeak();
+static void HandleWeakReference(
+    const v8::WeakCallbackData<v8::Object, Snorkel>& data) {
+  data.GetParameter()->prev_->ClearWeak();
+  delete data.GetParameter();
 }
 
 void WhammyPropertyGetter(Local<String> name,
@@ -6988,7 +7026,7 @@ void WhammyPropertyGetter(Local<String> name,
   if (!prev.IsEmpty()) {
     v8::Local<v8::Object>::New(info.GetIsolate(), prev)
         ->Set(v8_str("next"), obj);
-    prev.MakeWeak<Value, Snorkel>(new Snorkel(), &HandleWeakReference);
+    prev.SetWeak(new Snorkel(&prev), &HandleWeakReference);
   }
   whammy->objects_[whammy->cursor_].Reset(info.GetIsolate(), obj);
   whammy->cursor_ = (whammy->cursor_ + 1) % Whammy::kObjectCount;
@@ -7026,11 +7064,12 @@ THREADED_TEST(WeakReference) {
 }
 
 
-static void DisposeAndSetFlag(v8::Isolate* isolate,
-                              v8::Persistent<v8::Object>* obj,
-                              bool* data) {
-  obj->Reset();
-  *(data) = true;
+static void DisposeAndSetFlag(
+    const v8::WeakCallbackData<v8::Object,
+                               pair<v8::Persistent<v8::Object>*,
+                                    bool> >& data) {
+  data.GetParameter()->first->Reset();
+  data.GetParameter()->second = true;
 }
 
 
@@ -7048,17 +7087,17 @@ THREADED_TEST(IndependentWeakHandle) {
     object_b.Reset(iso, v8::Object::New());
   }
 
-  bool object_a_disposed = false;
-  bool object_b_disposed = false;
-  object_a.MakeWeak(&object_a_disposed, &DisposeAndSetFlag);
-  object_b.MakeWeak(&object_b_disposed, &DisposeAndSetFlag);
+  pair<v8::Persistent<v8::Object>*, bool> object_a_pair(&object_a, false);
+  pair<v8::Persistent<v8::Object>*, bool> object_b_pair(&object_b, false);
+  object_a.SetWeak(&object_a_pair, &DisposeAndSetFlag);
+  object_b.SetWeak(&object_b_pair, &DisposeAndSetFlag);
   CHECK(!object_b.IsIndependent());
   object_a.MarkIndependent();
   object_b.MarkIndependent();
   CHECK(object_b.IsIndependent());
   CcTest::heap()->PerformScavenge();
-  CHECK(object_a_disposed);
-  CHECK(object_b_disposed);
+  CHECK(object_a_pair.second);
+  CHECK(object_b_pair.second);
 }
 
 
@@ -7072,20 +7111,22 @@ static void InvokeMarkSweep() {
 }
 
 
-static void ForceScavenge(v8::Isolate* isolate,
-                          v8::Persistent<v8::Object>* obj,
-                          bool* data) {
-  obj->Reset();
-  *(data) = true;
+static void ForceScavenge(
+    const v8::WeakCallbackData<v8::Object,
+                               pair<v8::Persistent<v8::Object>*,
+                                    bool> >& data) {
+  data.GetParameter()->first->Reset();
+  data.GetParameter()->second = true;
   InvokeScavenge();
 }
 
 
-static void ForceMarkSweep(v8::Isolate* isolate,
-                           v8::Persistent<v8::Object>* obj,
-                           bool* data) {
-  obj->Reset();
-  *(data) = true;
+static void ForceMarkSweep(
+    const v8::WeakCallbackData<v8::Object,
+                               pair<v8::Persistent<v8::Object>*,
+                                    bool> >& data) {
+  data.GetParameter()->first->Reset();
+  data.GetParameter()->second = true;
   InvokeMarkSweep();
 }
 
@@ -7097,7 +7138,9 @@ THREADED_TEST(GCFromWeakCallbacks) {
   Context::Scope context_scope(context);
 
   static const int kNumberOfGCTypes = 2;
-  typedef v8::WeakReferenceCallbacks<v8::Object, bool>::Revivable Callback;
+  typedef v8::WeakCallbackData<v8::Object,
+                               pair<v8::Persistent<v8::Object>*,
+                                    bool> >::Callback Callback;
   Callback gc_forcing_callback[kNumberOfGCTypes] =
       {&ForceScavenge, &ForceMarkSweep};
 
@@ -7111,21 +7154,22 @@ THREADED_TEST(GCFromWeakCallbacks) {
         v8::HandleScope handle_scope(isolate);
         object.Reset(isolate, v8::Object::New());
       }
-      bool disposed = false;
-      object.MakeWeak(&disposed, gc_forcing_callback[inner_gc]);
+      pair<v8::Persistent<v8::Object>*, bool> object_pair(&object, false);
+      object.SetWeak(&object_pair, gc_forcing_callback[inner_gc]);
       object.MarkIndependent();
       invoke_gc[outer_gc]();
-      CHECK(disposed);
+      CHECK(object_pair.second);
     }
   }
 }
 
 
-static void RevivingCallback(v8::Isolate* isolate,
-                             v8::Persistent<v8::Object>* obj,
-                             bool* data) {
-  obj->ClearWeak();
-  *(data) = true;
+static void RevivingCallback(
+    const v8::WeakCallbackData<v8::Object,
+                               std::pair<v8::Persistent<Object>*,
+                                         bool> >& data) {
+  data.GetParameter()->first->ClearWeak();
+  data.GetParameter()->second = true;
 }
 
 
@@ -7144,11 +7188,11 @@ THREADED_TEST(IndependentHandleRevival) {
     v8::Local<String> y_str = v8_str("y");
     o->Set(y_str, y_str);
   }
-  bool revived = false;
-  object.MakeWeak(&revived, &RevivingCallback);
+  pair<v8::Persistent<v8::Object>*, bool> revived(&object, false);
+  object.SetWeak(&revived, &RevivingCallback);
   object.MarkIndependent();
   CcTest::heap()->PerformScavenge();
-  CHECK(revived);
+  CHECK(revived.second);
   CcTest::heap()->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
   {
     v8::HandleScope handle_scope(isolate);
@@ -13106,12 +13150,11 @@ TEST(WeakCallbackApi) {
 v8::Persistent<v8::Object> some_object;
 v8::Persistent<v8::Object> bad_handle;
 
-void NewPersistentHandleCallback(v8::Isolate* isolate,
-                                 v8::Persistent<v8::Value>* handle,
-                                 void*) {
-  v8::HandleScope scope(isolate);
-  bad_handle.Reset(isolate, some_object);
-  handle->Reset();
+void NewPersistentHandleCallback(
+    const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
+  v8::HandleScope scope(data.GetIsolate());
+  bad_handle.Reset(data.GetIsolate(), some_object);
+  data.GetParameter()->Reset();
 }
 
 
@@ -13130,7 +13173,7 @@ THREADED_TEST(NewPersistentHandleFromWeakCallback) {
   // global handle nodes are processed by PostGarbageCollectionProcessing
   // in reverse allocation order, so if second allocated handle is deleted,
   // weak callback of the first handle would be able to 'reallocate' it.
-  handle1.MakeWeak<v8::Value, void>(NULL, NewPersistentHandleCallback);
+  handle1.SetWeak(&handle1, NewPersistentHandleCallback);
   handle2.Reset();
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 }
@@ -13138,12 +13181,11 @@ THREADED_TEST(NewPersistentHandleFromWeakCallback) {
 
 v8::Persistent<v8::Object> to_be_disposed;
 
-void DisposeAndForceGcCallback(v8::Isolate* isolate,
-                               v8::Persistent<v8::Value>* handle,
-                               void*) {
+void DisposeAndForceGcCallback(
+    const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
   to_be_disposed.Reset();
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
-  handle->Reset();
+  data.GetParameter()->Reset();
 }
 
 
@@ -13157,23 +13199,21 @@ THREADED_TEST(DoNotUseDeletedNodesInSecondLevelGc) {
     handle1.Reset(isolate, v8::Object::New());
     handle2.Reset(isolate, v8::Object::New());
   }
-  handle1.MakeWeak<v8::Value, void>(NULL, DisposeAndForceGcCallback);
+  handle1.SetWeak(&handle1, DisposeAndForceGcCallback);
   to_be_disposed.Reset(isolate, handle2);
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 }
 
-void DisposingCallback(v8::Isolate* isolate,
-                       v8::Persistent<v8::Value>* handle,
-                       void*) {
-  handle->Reset();
+void DisposingCallback(
+    const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
+  data.GetParameter()->Reset();
 }
 
-void HandleCreatingCallback(v8::Isolate* isolate,
-                            v8::Persistent<v8::Value>* handle,
-                            void*) {
-  v8::HandleScope scope(isolate);
-  v8::Persistent<v8::Object>(isolate, v8::Object::New());
-  handle->Reset();
+void HandleCreatingCallback(
+    const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
+  v8::HandleScope scope(data.GetIsolate());
+  v8::Persistent<v8::Object>(data.GetIsolate(), v8::Object::New());
+  data.GetParameter()->Reset();
 }
 
 
@@ -13188,8 +13228,8 @@ THREADED_TEST(NoGlobalHandlesOrphaningDueToWeakCallback) {
     handle2.Reset(isolate, v8::Object::New());
     handle1.Reset(isolate, v8::Object::New());
   }
-  handle2.MakeWeak<v8::Value, void>(NULL, DisposingCallback);
-  handle3.MakeWeak<v8::Value, void>(NULL, HandleCreatingCallback);
+  handle2.SetWeak(&handle2, DisposingCallback);
+  handle3.SetWeak(&handle3, HandleCreatingCallback);
   CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
 }