remove phantom naming from the api

src/global-handles.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_GLOBAL_HANDLES_H_
 #define V8_GLOBAL_HANDLES_H_
 
 #include "include/v8.h"
 #include "include/v8-profiler.h"
 
@@ skipping 82 matching lines @@
   }
 
   UniqueId id;
   RetainedObjectInfo* info;
 };
 
 
 enum WeaknessType {
   NORMAL_WEAK,  // Embedder gets a handle to the dying object.
   // In the following cases, the embedder gets the parameter they passed in
-  // earlier, and the 0, 1 or 2 first internal fields. Note that the internal
+  // earlier, and 0 or 2 first internal fields. Note that the internal
   // fields must contain aligned non-V8 pointers.  Getting pointers to V8
   // objects through this interface would be GC unsafe so in that case the
   // embedder gets a null pointer instead.
-  PHANTOM_WEAK_0_INTERNAL_FIELDS,
-  PHANTOM_WEAK_1_INTERNAL_FIELDS,
+  PHANTOM_WEAK,
   PHANTOM_WEAK_2_INTERNAL_FIELDS
 };
 
 
 class GlobalHandles {
  public:
   ~GlobalHandles();
 
   // Creates a new global handle that is alive until Destroy is called.
   Handle<Object> Create(Object* value);
@@ skipping 19 matching lines @@
   // default the handle still contains a pointer to the object that is being
   // collected.  For this reason the object is not collected until the next
   // GC.  For a phantom weak handle the handle is cleared (set to a Smi)
   // before the callback is invoked, but the handle can still be identified
   // in the callback by using the location() of the handle.
   static void MakeWeak(Object** location, void* parameter,
                        WeakCallback weak_callback);
 
   // It would be nice to template this one, but it's really hard to get
   // the template instantiator to work right if you do.
-  static void MakePhantom(Object** location, void* parameter,
-                          int number_of_internal_fields,
-                          PhantomCallbackData<void>::Callback weak_callback);
+  static void MakeWeak(Object** location, void* parameter,
+                       WeakCallbackInfo<void>::Callback weak_callback,
+                       v8::WeakCallbackType type);
 
   void RecordStats(HeapStats* stats);
 
   // Returns the current number of weak handles.
   int NumberOfWeakHandles();
 
   // Returns the current number of weak handles to global objects.
   // These handles are also included in NumberOfWeakHandles().
   int NumberOfGlobalObjectWeakHandles();
 
@@ skipping 181 matching lines @@
   List<PendingPhantomCallback> pending_phantom_callbacks_;
 
   friend class Isolate;
 
   DISALLOW_COPY_AND_ASSIGN(GlobalHandles);
 };
 
 
 class GlobalHandles::PendingPhantomCallback {
  public:
-  typedef PhantomCallbackData<void> Data;
+  typedef v8::WeakCallbackInfo<void> Data;
   PendingPhantomCallback(Node* node, Data data, Data::Callback callback)
       : node_(node), data_(data), callback_(callback) {}
 
   void invoke();
 
   Node* node() { return node_; }
 
  private:
   Node* node_;
   Data data_;
@@ skipping 67 matching lines @@
   List<int> new_space_indices_;
   int singleton_handles_[NUMBER_OF_SINGLETON_HANDLES];
 
   DISALLOW_COPY_AND_ASSIGN(EternalHandles);
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_GLOBAL_HANDLES_H_