two pass phantom collection

include/v8.h

 // Copyright 2012 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.
 
 /** \mainpage V8 API Reference Guide
  *
  * V8 is Google's open source JavaScript engine.
  *
  * This set of documents provides reference material generated from the
  * V8 header file, include/v8.h.
@@ skipping 461 matching lines @@
 
 
 static const int kInternalFieldsInWeakCallback = 2;
 
 
 template <typename T>
 class WeakCallbackInfo {
  public:
   typedef void (*Callback)(const WeakCallbackInfo<T>& data);
 
-  WeakCallbackInfo(Isolate* isolate, T* parameter, void* internal_field1,
-                   void* internal_field2)
-      : isolate_(isolate), parameter_(parameter) {
-    internal_fields_[0] = internal_field1;
-    internal_fields_[1] = internal_field2;
+  WeakCallbackInfo(Isolate* isolate, T* parameter,
+                   void* internal_fields[kInternalFieldsInWeakCallback],
+                   Callback* callback)
+      : isolate_(isolate), parameter_(parameter), callback_(callback) {
+    for (int i = 0; i < kInternalFieldsInWeakCallback; ++i) {
+      internal_fields_[i] = internal_fields[i];
+    }
   }
 
   V8_INLINE Isolate* GetIsolate() const { return isolate_; }
   V8_INLINE T* GetParameter() const { return parameter_; }
   V8_INLINE void* GetInternalField(int index) const;
 
   V8_INLINE V8_DEPRECATE_SOON("use indexed version",
                               void* GetInternalField1()) const {
     return internal_fields_[0];
   }
   V8_INLINE V8_DEPRECATE_SOON("use indexed version",
                               void* GetInternalField2()) const {
     return internal_fields_[1];
   }
 
+  bool IsFirstPass() const { return callback_ != nullptr; }
+
+  // When first called, the embedder MUST Reset() the Global which triggered the
+  // callback. The Global itself is unusable for anything else. No v8 other api
+  // calls may be called in the first callback. Should additional work be
+  // required, the embedder must set a second pass callback, which will be
+  // called after all the initial callbacks are processed.
+  // Calling SetSecondPassCallback on the second pass will immediately crash.
+  void SetSecondPassCallback(Callback callback) const { *callback_ = callback; }
+
  private:
   Isolate* isolate_;
   T* parameter_;
-  void* internal_fields_[2];
+  Callback* callback_;
+  void* internal_fields_[kInternalFieldsInWeakCallback];
 };
 
 
 template <class T, class P>
 class WeakCallbackData {
  public:
   typedef void (*Callback)(const WeakCallbackData<T, P>& data);
 
   WeakCallbackData(Isolate* isolate, P* parameter, Local<T> handle)
       : isolate_(isolate), parameter_(parameter), handle_(handle) {}
@@ skipping 7478 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_