remove phantom naming from the api

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 6254 matching lines @@
   v8::V8::RemoveMessageListeners(MissingScriptInfoMessageListener);
 }
 
 
 struct FlagAndPersistent {
   bool flag;
   v8::Persistent<v8::Object> handle;
 };
 
 
-static void SetFlag(const v8::PhantomCallbackData<FlagAndPersistent>& data) {
+static void SetFlag(const v8::WeakCallbackInfo<FlagAndPersistent>& data) {
   data.GetParameter()->flag = true;
 }
 
 
 static void IndependentWeakHandle(bool global_gc, bool interlinked) {
   v8::Isolate* iso = CcTest::isolate();
   v8::HandleScope scope(iso);
   v8::Handle<Context> context = Context::New(iso);
   Context::Scope context_scope(context);
 
@@ skipping 18 matching lines @@
     }
     // We are relying on this creating a big flag array and reserving the space
     // up front.
     v8::Handle<Value> big_array = CompileRun("new Array(50000)");
     a->Set(v8_str("y"), big_array);
     big_heap_size = CcTest::heap()->SizeOfObjects();
   }
 
   object_a.flag = false;
   object_b.flag = false;
-  object_a.handle.SetPhantom(&object_a, &SetFlag);
-  object_b.handle.SetPhantom(&object_b, &SetFlag);
+  object_a.handle.SetWeak(&object_a, &SetFlag,
+                          v8::WeakCallbackType::kParameter);
+  object_b.handle.SetWeak(&object_b, &SetFlag,
+                          v8::WeakCallbackType::kParameter);
   CHECK(!object_b.handle.IsIndependent());
   object_a.handle.MarkIndependent();
   object_b.handle.MarkIndependent();
   CHECK(object_b.handle.IsIndependent());
   if (global_gc) {
     CcTest::heap()->CollectAllGarbage(TestHeap::Heap::kNoGCFlags);
   } else {
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);
   }
   // A single GC should be enough to reclaim the memory, since we are using
@@ skipping 34 matching lines @@
   int y() { return y_; }
   void set_y(int y) { y_ = y; }
 
  private:
   int y_;
   int x_;
 };
 
 
 void CheckInternalFields(
-    const v8::PhantomCallbackData<v8::Persistent<v8::Object>>& data) {
+    const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) {
   v8::Persistent<v8::Object>* handle = data.GetParameter();
   handle->Reset();
   Trivial* t1 = reinterpret_cast<Trivial*>(data.GetInternalField1());
   Trivial2* t2 = reinterpret_cast<Trivial2*>(data.GetInternalField2());
   CHECK_EQ(42, t1->x());
   CHECK_EQ(103, t2->x());
   t1->set_x(1729);
   t2->set_x(33550336);
 }
 
@@ skipping 19 matching lines @@
 
     obj->SetAlignedPointerInInternalField(0, t1);
     t1 = reinterpret_cast<Trivial*>(obj->GetAlignedPointerFromInternalField(0));
     CHECK_EQ(42, t1->x());
 
     obj->SetAlignedPointerInInternalField(1, t2);
     t2 =
         reinterpret_cast<Trivial2*>(obj->GetAlignedPointerFromInternalField(1));
     CHECK_EQ(103, t2->x());
 
-    handle.SetPhantom<v8::Persistent<v8::Object>>(&handle, CheckInternalFields,
-                                                  0, 1);
+    handle.SetWeak<v8::Persistent<v8::Object>>(
+        &handle, CheckInternalFields, v8::WeakCallbackType::kInternalFields);
     if (!global_gc) {
       handle.MarkIndependent();
     }
   }
   if (global_gc) {
     CcTest::heap()->CollectAllGarbage(TestHeap::Heap::kNoGCFlags);
   } else {
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);
   }
 
@@ skipping 15216 matching lines @@
   }
   {
     v8::TryCatch try_catch;
     uint16_t* data = reinterpret_cast<uint16_t*>(buffer);
     CHECK(v8::String::NewFromTwoByte(isolate, data, v8::String::kNormalString,
                                      length).IsEmpty());
     CHECK(try_catch.HasCaught());
   }
   free(buffer);
 }