Fix the "PersistentValueMap" memory leak reported here:

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 282 matching lines @@
   }
 
   static void WeakCallback(
       const WeakCallbackData<V, typename Traits::WeakCallbackDataType>& data) {
     if (Traits::kCallbackType != kNotWeak) {
       PersistentValueMap<K, V, Traits>* persistentValueMap =
           Traits::MapFromWeakCallbackData(data);
       K key = Traits::KeyFromWeakCallbackData(data);
       Traits::Dispose(data.GetIsolate(),
                       persistentValueMap->Remove(key).Pass(), key);
+      Traits::DisposeCallbackData(data.GetParameter());
     }
   }
 
   static V* FromVal(PersistentContainerValue v) {
     return reinterpret_cast<V*>(v);
   }
 
   static bool SetReturnValueFromVal(
       ReturnValue<Value>& returnValue, PersistentContainerValue value) {
     bool hasValue = value != kPersistentContainerNotFound;
@@ skipping 17 matching lines @@
   }
 
   /**
    * Return a container value as UniquePersistent and make sure the weak
    * callback is properly disposed of. All remove functionality should go
    * through this.
    */
   static UniquePersistent<V> Release(PersistentContainerValue v) {
     UniquePersistent<V> p;
     p.val_ = FromVal(v);
-    if (Traits::kCallbackType != kNotWeak && !p.IsEmpty()) {
+    if (Traits::kCallbackType != kNotWeak && p.IsWeak()) {
       Traits::DisposeCallbackData(
           p.template ClearWeak<typename Traits::WeakCallbackDataType>());
     }
     return p.Pass();
   }
 
   Isolate* isolate_;
   typename Traits::Impl impl_;
 };
 
@@ skipping 126 matching lines @@
     return reinterpret_cast<V*>(v);
   }
 
   Isolate* isolate_;
   typename Traits::Impl impl_;
 };
 
 }  // namespace v8
 
 #endif  // V8_UTIL_H_