simplify GlobalValueMap calls to DisposeWeak

include/v8-util.h

 // Copyright 2014 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_UTIL_H_
 #define V8_UTIL_H_
 
 #include "v8.h"
 #include <map>
 #include <vector>
@@ skipping 116 matching lines @@
   static MapType* MapFromWeakCallbackInfo(
       const WeakCallbackInfo<WeakCallbackInfoType>& data) {
     return nullptr;
   }
   static K KeyFromWeakCallbackInfo(
       const WeakCallbackInfo<WeakCallbackInfoType>& data) {
     return K();
   }
   static void DisposeCallbackData(WeakCallbackInfoType* data) {}
   static void Dispose(Isolate* isolate, Global<V> value, K key) {}
-  static void DisposeWeak(Isolate* isolate,
-                          const WeakCallbackInfo<WeakCallbackInfoType>& data,
-                          K key) {}
+  // This is a second pass callback, so SetSecondPassCallback cannot be called.
+  static void DisposeWeak(const WeakCallbackInfo<WeakCallbackInfoType>& data) {}
 
  private:
   template <typename T>
   struct RemovePointer<T*> {
     typedef T Type;
   };
 };
 
 
 /**
@@ skipping 296 matching lines @@
    * by the Traits class.
    */
   Global<V> SetUnique(const K& key, Global<V>* persistent) {
     if (Traits::kCallbackType != kNotWeak) {
       WeakCallbackType callback_type =
           Traits::kCallbackType == kWeakWithInternalFields
               ? WeakCallbackType::kInternalFields
               : WeakCallbackType::kParameter;
       Local<V> value(Local<V>::New(this->isolate(), *persistent));
       persistent->template SetWeak<typename Traits::WeakCallbackDataType>(
-          Traits::WeakCallbackParameter(this, key, value), WeakCallback,
+          Traits::WeakCallbackParameter(this, key, value), FirstWeakCallback,
           callback_type);
     }
     PersistentContainerValue old_value =
         Traits::Set(this->impl(), key, this->ClearAndLeak(persistent));
     return this->Release(old_value).Pass();
   }
 
   /**
    * Put a value into the map and update the reference.
    * Restrictions of GetReference apply here as well.
    */
   Global<V> Set(const K& key, Global<V> value,
                 PersistentValueReference* reference) {
     *reference = this->Leak(&value);
     return SetUnique(key, &value);
   }
 
  private:
-  static void WeakCallback(
+  static void FirstWeakCallback(
       const WeakCallbackInfo<typename Traits::WeakCallbackDataType>& data) {
     if (Traits::kCallbackType != kNotWeak) {
-      GlobalValueMap<K, V, Traits>* persistentValueMap =
-          Traits::MapFromWeakCallbackInfo(data);
+      auto map = Traits::MapFromWeakCallbackInfo(data);
       K key = Traits::KeyFromWeakCallbackInfo(data);
-      persistentValueMap->RemoveWeak(key);
-      Traits::DisposeWeak(data.GetIsolate(), data, key);
+      map->RemoveWeak(key);
+      data.SetSecondPassCallback(SecondWeakCallback);
     }
   }
+
+  static void SecondWeakCallback(
+      const WeakCallbackInfo<typename Traits::WeakCallbackDataType>& data) {
+    Traits::DisposeWeak(data);
+  }
 };
 
 
 /**
  * A map that uses Global as value and std::map as the backing
  * implementation. Persistents are held non-weak.
  *
  * C++11 embedders don't need this class, as they can use
  * Global directly in std containers.
  */
@@ skipping 117 matching lines @@
     return reinterpret_cast<V*>(v);
   }
 
   Isolate* isolate_;
   typename Traits::Impl impl_;
 };
 
 }  // namespace v8
 
 #endif  // V8_UTIL_H