1 files changed, 34 insertions, 15 deletions

diff --git a/deps/v8/include/v8-util.h b/deps/v8/include/v8-util.h
index b01d527754..6454a19b7e 100644
--- a/deps/v8/include/v8-util.h
+++ b/deps/v8/include/v8-util.h
@@ -117,26 +117,25 @@ class DefaultGlobalMapTraits : public StdMapTraits<K, V> {
  public:
   // Weak callback & friends:
   static const PersistentContainerCallbackType kCallbackType = kNotWeak;
-  typedef PersistentValueMap<K, V, DefaultGlobalMapTraits<K, V> > MapType;
-  typedef void WeakCallbackInfoType;
+  typedef GlobalValueMap<K, V, DefaultGlobalMapTraits<K, V> > MapType;
+  typedef void WeakCallbackDataType;
 
-  static WeakCallbackInfoType* WeakCallbackParameter(MapType* map, const K& key,
+  static WeakCallbackDataType* WeakCallbackParameter(MapType* map, const K& key,
                                                      Local<V> value) {
     return nullptr;
   }
   static MapType* MapFromWeakCallbackInfo(
-      const WeakCallbackInfo<WeakCallbackInfoType>& data) {
+      const WeakCallbackInfo<WeakCallbackDataType>& data) {
     return nullptr;
   }
   static K KeyFromWeakCallbackInfo(
-      const WeakCallbackInfo<WeakCallbackInfoType>& data) {
+      const WeakCallbackInfo<WeakCallbackDataType>& data) {
     return K();
   }
-  static void DisposeCallbackData(WeakCallbackInfoType* data) {}
+  static void DisposeCallbackData(WeakCallbackDataType* 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<WeakCallbackDataType>& data) {}
 
  private:
   template <typename T>
@@ -453,7 +452,7 @@ class GlobalValueMap : public PersistentValueMapBase<K, V, Traits> {
               : 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 =
@@ -472,16 +471,20 @@ class GlobalValueMap : public PersistentValueMapBase<K, V, Traits> {
   }
 
  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);
+  }
 };
 
 
@@ -501,6 +504,22 @@ class StdPersistentValueMap : public PersistentValueMap<K, V, Traits> {
 };
 
 
+/**
+ * A map that uses Global as value and std::map as the backing
+ * implementation. Globals are held non-weak.
+ *
+ * C++11 embedders don't need this class, as they can use
+ * Global directly in std containers.
+ */
+template <typename K, typename V,
+          typename Traits = DefaultGlobalMapTraits<K, V> >
+class StdGlobalValueMap : public GlobalValueMap<K, V, Traits> {
+ public:
+  explicit StdGlobalValueMap(Isolate* isolate)
+      : GlobalValueMap<K, V, Traits>(isolate) {}
+};
+
+
 class DefaultPersistentValueVectorTraits {
  public:
   typedef std::vector<PersistentContainerValue> Impl;