fix disposal of phantom handles in GlobalValueMap

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) {}
 
  private:
   template <typename T>
   struct RemovePointer<T*> {
     typedef T Type;
   };
 };
 
 
 /**
@@ skipping 165 matching lines @@
   static Global<V> Release(PersistentContainerValue v) {
     Global<V> p;
     p.val_ = FromVal(v);
     if (Traits::kCallbackType != kNotWeak && p.IsWeak()) {
       Traits::DisposeCallbackData(
           p.template ClearWeak<typename Traits::WeakCallbackDataType>());
     }
     return p.Pass();
   }
 
+  void RemoveWeak(const K& key) { Traits::Remove(&impl_, key); }
+
  private:
   PersistentValueMapBase(PersistentValueMapBase&);
   void operator=(PersistentValueMapBase&);
 
   static bool SetReturnValueFromVal(ReturnValue<Value>* returnValue,
                                     PersistentContainerValue value) {
     bool hasValue = value != kPersistentContainerNotFound;
     if (hasValue) {
       returnValue->SetInternal(
           *reinterpret_cast<internal::Object**>(FromVal(value)));
@@ skipping 130 matching lines @@
     return SetUnique(key, &value);
   }
 
  private:
   static void WeakCallback(
       const WeakCallbackInfo<typename Traits::WeakCallbackDataType>& data) {
     if (Traits::kCallbackType != kNotWeak) {
       GlobalValueMap<K, V, Traits>* persistentValueMap =
           Traits::MapFromWeakCallbackInfo(data);
       K key = Traits::KeyFromWeakCallbackInfo(data);
-      Traits::Dispose(data.GetIsolate(), persistentValueMap->Remove(key).Pass(),
-                      key);
+      persistentValueMap->RemoveWeak(key);
+      Traits::DisposeWeak(data.GetIsolate(), data, key);
       Traits::DisposeCallbackData(data.GetParameter());
     }
   }
 };
 
 
 /**
  * A map that uses Global as value and std::map as the backing
  * implementation. Persistents are held non-weak.
  *
@@ skipping 120 matching lines @@
     return reinterpret_cast<V*>(v);
   }
 
   Isolate* isolate_;
   typename Traits::Impl impl_;
 };
 
 }  // namespace v8
 
 #endif  // V8_UTIL_H