Introduce a new phantom weakness type without finalization callback.

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 79 matching lines @@
 
   bool operator<(const ObjectGroupRetainerInfo& other) const {
     return id < other.id;
   }
 
   UniqueId id;
   RetainedObjectInfo* info;
 };
 
 enum WeaknessType {
+  // Embedder gets a handle to the dying object.
+  FINALIZER_WEAK,
   // In the following cases, the embedder gets the parameter they passed in
   // 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,
   PHANTOM_WEAK_2_INTERNAL_FIELDS,
-  // Embedder gets a handle to the dying object.
-  FINALIZER_WEAK,
+  // The handle is automatically reset by the garbage collector when
+  // the object is no longer reachable.
+  PHANTOM_WEAK_RESET_HANDLE
 };
 
 class GlobalHandles {
  public:
   ~GlobalHandles();
 
   // Creates a new global handle that is alive until Destroy is called.
   Handle<Object> Create(Object* value);
 
   // Copy a global handle
   static Handle<Object> CopyGlobal(Object** location);
 
   // Destroy a global handle.
   static void Destroy(Object** location);
 
   // Make the global handle weak and set the callback parameter for the
   // handle.  When the garbage collector recognizes that only weak global
   // handles point to an object the callback function is invoked (for each
   // handle) with the handle and corresponding parameter as arguments.  By
   // 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,
                        WeakCallbackInfo<void>::Callback weak_callback,
                        v8::WeakCallbackType type);
 
+  static void MakeWeak(Object*** location_addr);
+
   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();
 
   // Returns the current number of handles to global objects.
   int global_handles_count() const {
     return number_of_global_handles_;
   }
 
+  size_t NumberOfPhantomHandleResets() {
+    return number_of_phantom_handle_resets_;
+  }
+
+  void ResetNumberOfPhantomHandleResets() {
+    number_of_phantom_handle_resets_ = 0;
+  }
+
   // Clear the weakness of a global handle.
   static void* ClearWeakness(Object** location);
 
   // Mark the reference to this object independent of any object group.
   static void MarkIndependent(Object** location);
 
   // Mark the reference to this object externaly unreachable.
   static void MarkPartiallyDependent(Object** location);
 
   static bool IsIndependent(Object** location);
@@ skipping 162 matching lines @@
 
   // Free list of nodes.
   Node* first_free_;
 
   // Contains all nodes holding new space objects. Note: when the list
   // is accessed, some of the objects may have been promoted already.
   List<Node*> new_space_nodes_;
 
   int post_gc_processing_count_;
 
+  size_t number_of_phantom_handle_resets_;
+
   // Object groups and implicit references, public and more efficient
   // representation.
   List<ObjectGroup*> object_groups_;
   List<ImplicitRefGroup*> implicit_ref_groups_;
 
   // Object groups and implicit references, temporary representation while
   // constructing the groups.
   List<ObjectGroupConnection> object_group_connections_;
   List<ObjectGroupRetainerInfo> retainer_infos_;
   List<ObjectGroupConnection> implicit_ref_connections_;
@@ skipping 98 matching lines @@
   int singleton_handles_[NUMBER_OF_SINGLETON_HANDLES];
 
   DISALLOW_COPY_AND_ASSIGN(EternalHandles);
 };
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_GLOBAL_HANDLES_H_